50 #include "llvm/ADT/ArrayRef.h"
51 #include "llvm/ADT/STLExtras.h"
52 #include "llvm/ADT/STLForwardCompat.h"
53 #include "llvm/ADT/ScopeExit.h"
54 #include "llvm/ADT/SmallString.h"
55 #include "llvm/ADT/StringExtras.h"
56 #include "llvm/Support/ConvertUTF.h"
57 #include "llvm/Support/SaveAndRestore.h"
62 using namespace clang;
74 class CheckDefaultArgumentVisitor
77 const Expr *DefaultArg;
80 CheckDefaultArgumentVisitor(
Sema &S,
const Expr *DefaultArg)
81 : S(S), DefaultArg(DefaultArg) {}
86 bool VisitLambdaExpr(
const LambdaExpr *Lambda);
91 bool CheckDefaultArgumentVisitor::VisitExpr(
const Expr *
Node) {
92 bool IsInvalid =
false;
93 for (
const Stmt *SubStmt :
Node->children())
95 IsInvalid |= Visit(SubStmt);
102 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(
const DeclRefExpr *DRE) {
105 if (!isa<VarDecl, BindingDecl>(
Decl))
108 if (
const auto *Param = dyn_cast<ParmVarDecl>(
Decl)) {
119 diag::err_param_default_argument_references_param)
120 << Param->getDeclName() << DefaultArg->getSourceRange();
121 }
else if (
auto *VD =
Decl->getPotentiallyDecomposedVarDecl()) {
136 diag::err_param_default_argument_references_local)
143 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(
const CXXThisExpr *ThisE) {
148 diag::err_param_default_argument_references_this)
152 bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(
157 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {
158 E = OVE->getSourceExpr();
159 assert(E &&
"pseudo-object binding without source expression?");
167 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(
const LambdaExpr *Lambda) {
176 return S.
Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
178 auto *D = cast<VarDecl>(LC.getCapturedVar());
179 Invalid |= Visit(D->getInit());
211 llvm_unreachable(
"should not see unresolved exception specs here");
240 "should not generate implicit declarations for dependent cases");
244 assert(EST ==
EST_Dynamic &&
"EST case not considered earlier.");
246 "Shouldn't collect exceptions when throw-all is guaranteed.");
251 Exceptions.push_back(E);
279 if (Self->canThrow(S))
286 diag::err_typecheck_decl_incomplete_type))
301 if (Result.isInvalid())
303 Arg = Result.getAs<
Expr>();
305 CheckCompletedExpr(Arg, EqualLoc);
318 UnparsedDefaultArgInstantiationsMap::iterator InstPos
321 for (
unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
322 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
335 if (!param || !DefaultArg)
343 Diag(EqualLoc, diag::err_param_default_argument)
356 Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
364 if (Result.isInvalid())
367 DefaultArg = Result.getAs<
Expr>();
370 CheckDefaultArgumentVisitor DefaultArgChecker(*
this, DefaultArg);
371 if (DefaultArgChecker.Visit(DefaultArg))
408 Param->
getType().getNonReferenceType());
430 if (MightBeFunction) {
434 MightBeFunction =
false;
437 for (
unsigned argIdx = 0, e = chunk.
Fun.
NumParams; argIdx != e;
441 std::unique_ptr<CachedTokens> Toks =
444 if (Toks->size() > 1)
446 Toks->back().getLocation());
458 MightBeFunction =
false;
465 return P->hasDefaultArg() && !P->hasInheritedDefaultArg();
475 bool Invalid =
false;
486 for (; PrevForDefaultArgs;
534 for (
unsigned p = 0, NumParams = PrevForDefaultArgs
537 p < NumParams; ++p) {
541 bool OldParamHasDfl = OldParam ? OldParam->
hasDefaultArg() :
false;
544 if (OldParamHasDfl && NewParamHasDfl) {
545 unsigned DiagDefaultParamID =
546 diag::err_param_default_argument_redefinition;
561 DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
579 for (
auto Older = PrevForDefaultArgs;
581 Older = Older->getPreviousDecl();
582 OldParam = Older->getParamDecl(p);
587 }
else if (OldParamHasDfl) {
605 }
else if (NewParamHasDfl) {
609 diag::err_param_default_argument_template_redecl)
612 diag::note_template_prev_declaration)
643 if (
Record->getDescribedClassTemplate())
645 else if (isa<ClassTemplatePartialSpecializationDecl>(
Record))
652 diag::err_param_default_argument_member_template_redecl)
662 if (isa<CXXConstructorDecl>(New) &&
666 if (NewSM != OldSM) {
669 Diag(NewParam->
getLocation(), diag::err_default_arg_makes_ctor_special)
704 if (isa<CXXDeductionGuideDecl>(New) &&
716 Diag(New->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
737 ? diag::warn_cxx23_placeholder_var_definition
738 : diag::ext_placeholder_var_definition);
756 if (!TemplateParamLists.empty()) {
759 Diag(TemplateParamLists.front()->getTemplateLoc(),
760 diag::err_decomp_decl_template);
766 ? diag::ext_decomp_decl
768 ? diag::ext_decomp_decl_cond
769 : diag::warn_cxx14_compat_decomp_decl)
792 if (
auto SCS = DS.getStorageClassSpec()) {
795 CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
798 BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
801 if (
auto TSCS = DS.getThreadStorageClassSpec()) {
803 CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
805 if (DS.hasConstexprSpecifier()) {
806 BadSpecifiers.push_back(
808 BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
810 if (DS.isInlineSpecified()) {
811 BadSpecifiers.push_back(
"inline");
812 BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
815 if (!BadSpecifiers.empty()) {
816 auto &&Err =
Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
817 Err << (
int)BadSpecifiers.size()
818 << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),
" ");
821 for (
auto Loc : BadSpecifierLocs)
823 }
else if (!CPlusPlus20Specifiers.empty()) {
824 auto &&Warn =
Diag(CPlusPlus20SpecifierLocs.front(),
826 ? diag::warn_cxx17_compat_decomp_decl_spec
827 : diag::ext_decomp_decl_spec);
828 Warn << (
int)CPlusPlus20Specifiers.size()
829 << llvm::join(CPlusPlus20Specifiers.begin(),
830 CPlusPlus20Specifiers.end(),
" ");
831 for (
auto Loc : CPlusPlus20SpecifierLocs)
843 Diag(DS.getVolatileSpecLoc(),
844 diag::warn_deprecated_volatile_structured_binding);
864 ? diag::err_decomp_decl_parens
865 : diag::err_decomp_decl_type)
876 if (DS.isConstrainedAuto()) {
879 "No other template kind should be possible for a constrained auto");
897 assert(VarName &&
"Cannot have an unnamed binding declaration");
906 Previous.getFoundDecl()->isTemplateParameter()) {
938 auto *Old =
Previous.getRepresentativeDecl();
939 Diag(B.NameLoc, diag::err_redefinition) << B.Name;
940 Diag(Old->getLocation(), diag::note_previous_definition);
958 bool AddToScope =
true;
967 if (
OpenMP().isInOpenMPDeclareTargetContext())
978 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
991 E = GetInit(Loc, E.
get(), I++);
994 B->setBinding(ElemType, E.
get());
1006 S,
Bindings, Src, DecompType, NumElems, ElemType,
1037 S,
Bindings, Src, DecompType, llvm::APSInt::get(2),
1041 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1049 llvm::raw_svector_ostream OS(SS);
1061 return std::string(OS.str());
1068 auto DiagnoseMissing = [&] {
1078 return DiagnoseMissing();
1088 return DiagnoseMissing();
1089 if (Result.isAmbiguous())
1094 Result.suppressDiagnostics();
1096 S.
Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1108 Loc, TraitTy, DiagID,
1115 assert(RD &&
"specialization of class template is not a class?");
1134 namespace {
enum class IsTupleLike { TupleLike, NotTupleLike,
Error }; }
1152 return IsTupleLike::NotTupleLike;
1161 : R(R), Args(Args) {}
1162 Sema::SemaDiagnosticBuilder diagnoseNotICE(
Sema &S,
1164 return S.
Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1168 } Diagnoser(R, Args);
1179 return IsTupleLike::TupleLike;
1194 S, R, Loc,
"tuple_element", Args,
1195 diag::err_decomp_decl_std_tuple_element_not_specialized))
1201 S.
Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1213 struct InitializingBinding {
1222 ~InitializingBinding() {
1233 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1249 bool UseMemberGet =
false;
1259 dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
1261 if (TPL->
size() != 0 &&
1262 isa<NonTypeTemplateParmDecl>(TPL->
getParam(0))) {
1264 UseMemberGet =
true;
1273 InitializingBinding InitContext(S, B);
1296 MemberGet, &Args,
nullptr);
1331 B->getDeclName().getAsIdentifierInfo(), RefType,
1335 RefVD->setImplicit();
1337 RefVD->setInlineSpecified();
1338 RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);
1343 E =
Seq.Perform(S, Entity,
Kind, Init);
1349 RefVD->setInit(E.
get());
1358 B->setBinding(
T, E.
get());
1373 return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
1382 ClassWithFields = RD;
1394 for (
auto &
P : Paths) {
1398 BestPath->back().Base->getType())) {
1400 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1401 <<
false << RD << BestPath->back().Base->getType()
1402 <<
P.back().Base->getType();
1404 }
else if (
P.Access < BestPath->
Access) {
1410 QualType BaseType = BestPath->back().Base->getType();
1412 S.
Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1419 *BestPath, diag::err_decomp_decl_inaccessible_base);
1430 S.
Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1431 << (ClassWithFields == RD) << RD << ClassWithFields
1432 << Paths.front().back().Base->getType();
1443 diag::err_incomplete_type))
1455 auto DiagnoseBadNumberOfBindings = [&]() ->
bool {
1456 unsigned NumFields = llvm::count_if(
1457 RD->
fields(), [](
FieldDecl *FD) { return !FD->isUnnamedBitField(); });
1458 assert(
Bindings.size() != NumFields);
1459 S.
Diag(Src->
getLocation(), diag::err_decomp_decl_wrong_number_bindings)
1469 for (
auto *FD : RD->
fields()) {
1470 if (FD->isUnnamedBitField())
1475 if (!FD->getDeclName()) {
1482 if (FD->isAnonymousStructOrUnion()) {
1485 S.
Diag(FD->getLocation(), diag::note_declared_at);
1494 return DiagnoseBadNumberOfBindings();
1505 BasePair.
getAccess(), FD->getAccess())));
1528 if (FD->isMutable())
1534 return DiagnoseBadNumberOfBindings();
1582 case IsTupleLike::TupleLike:
1587 case IsTupleLike::NotTupleLike:
1596 << DD << !RD << DecompType;
1619 "Should only be called if types are otherwise the same.");
1630 NewType =
P->getPointeeType();
1663 if (FTD->isMemberSpecialization())
1687 diag::err_param_default_argument_missing_name)
1691 diag::err_param_default_argument_missing);
1699 template <
typename... Ts>
1709 std::forward<Ts>(DiagArgs)...);
1715 llvm_unreachable(
"unknown CheckConstexprKind");
1723 "this check is obsolete for C++23");
1734 SemaRef.
Diag(Loc, diag::note_constexpr_dtor_subobject)
1742 if (!Check(B.getBaseTypeLoc(), B.getType(),
nullptr))
1745 if (!Check(FD->getLocation(), FD->getType(), FD))
1756 "this check is obsolete for C++23");
1757 unsigned ArgIndex = 0;
1760 e = FT->param_type_end();
1761 i != e; ++i, ++ArgIndex) {
1763 assert(PD &&
"null in a parameter list");
1766 diag::err_constexpr_non_literal_param, ArgIndex + 1,
1779 "this check is obsolete for C++23");
1781 diag::err_constexpr_non_literal_return,
1800 default: llvm_unreachable(
"Invalid tag kind for record diagnostic!");
1831 << isa<CXXConstructorDecl>(NewFD)
1833 for (
const auto &I : RD->
vbases())
1834 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
1835 << I.getSourceRange();
1840 if (!isa<CXXConstructorDecl>(NewFD)) {
1845 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
1849 Diag(Method->
getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
1862 if (WrittenVirtual != Method)
1864 diag::note_overridden_virtual_function);
1875 if (
auto *Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {
1880 !Dtor->getParent()->defaultedDestructorIsConstexpr()) {
1895 "CheckConstexprFunctionDefinition called on function with no body");
1910 for (
const auto *DclIt : DS->
decls()) {
1911 switch (DclIt->getKind()) {
1912 case Decl::StaticAssert:
1914 case Decl::UsingShadow:
1915 case Decl::UsingDirective:
1916 case Decl::UnresolvedUsingTypename:
1917 case Decl::UnresolvedUsingValue:
1918 case Decl::UsingEnum:
1926 case Decl::TypeAlias: {
1929 const auto *TN = cast<TypedefNameDecl>(DclIt);
1930 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
1933 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
1936 << isa<CXXConstructorDecl>(Dcl);
1944 case Decl::CXXRecord:
1946 if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {
1950 ? diag::warn_cxx11_compat_constexpr_type_definition
1951 : diag::ext_constexpr_type_definition)
1952 << isa<CXXConstructorDecl>(Dcl);
1959 case Decl::EnumConstant:
1960 case Decl::IndirectField:
1967 case Decl::Decomposition: {
1972 const auto *VD = cast<VarDecl>(DclIt);
1973 if (VD->isThisDeclarationADefinition()) {
1974 if (VD->isStaticLocal()) {
1978 ? diag::warn_cxx20_compat_constexpr_var
1979 : diag::ext_constexpr_static_var)
1980 << isa<CXXConstructorDecl>(Dcl)
1988 diag::warn_cxx20_compat_constexpr_var,
1989 isa<CXXConstructorDecl>(Dcl),
1993 diag::err_constexpr_local_var_non_literal_type,
1994 isa<CXXConstructorDecl>(Dcl))) {
1997 if (!VD->getType()->isDependentType() &&
1998 !VD->hasInit() && !VD->isCXXForRangeDecl()) {
2003 ? diag::warn_cxx17_compat_constexpr_local_var_no_init
2004 : diag::ext_constexpr_local_var_no_init)
2005 << isa<CXXConstructorDecl>(Dcl);
2015 ? diag::warn_cxx11_compat_constexpr_local_var
2016 : diag::ext_constexpr_local_var)
2017 << isa<CXXConstructorDecl>(Dcl);
2024 case Decl::NamespaceAlias:
2025 case Decl::Function:
2035 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2060 llvm::SmallSet<Decl*, 16> &Inits,
2068 if (Field->isInvalidDecl())
2071 if (Field->isUnnamedBitField())
2077 if (Field->isAnonymousStructOrUnion() &&
2078 (Field->getType()->isUnionType()
2079 ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
2080 : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
2083 if (!Inits.count(Field)) {
2088 ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
2089 : diag::ext_constexpr_ctor_missing_init);
2093 diag::note_constexpr_ctor_missing_init);
2097 }
else if (Field->isAnonymousStructOrUnion()) {
2099 for (
auto *I : RD->
fields())
2102 if (!RD->
isUnion() || Inits.count(I))
2119 switch (S->getStmtClass()) {
2120 case Stmt::NullStmtClass:
2124 case Stmt::DeclStmtClass:
2134 case Stmt::ReturnStmtClass:
2136 if (isa<CXXConstructorDecl>(Dcl)) {
2139 Cxx1yLoc = S->getBeginLoc();
2143 ReturnStmts.push_back(S->getBeginLoc());
2146 case Stmt::AttributedStmtClass:
2150 SemaRef, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,
2151 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind);
2153 case Stmt::CompoundStmtClass: {
2156 Cxx1yLoc = S->getBeginLoc();
2159 for (
auto *BodyIt : CompStmt->
body()) {
2161 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2167 case Stmt::IfStmtClass: {
2170 Cxx1yLoc = S->getBeginLoc();
2174 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2176 if (
If->getElse() &&
2178 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2183 case Stmt::WhileStmtClass:
2184 case Stmt::DoStmtClass:
2185 case Stmt::ForStmtClass:
2186 case Stmt::CXXForRangeStmtClass:
2187 case Stmt::ContinueStmtClass:
2193 Cxx1yLoc = S->getBeginLoc();
2194 for (
Stmt *SubStmt : S->children()) {
2197 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2202 case Stmt::SwitchStmtClass:
2203 case Stmt::CaseStmtClass:
2204 case Stmt::DefaultStmtClass:
2205 case Stmt::BreakStmtClass:
2209 Cxx1yLoc = S->getBeginLoc();
2210 for (
Stmt *SubStmt : S->children()) {
2213 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2218 case Stmt::LabelStmtClass:
2219 case Stmt::GotoStmtClass:
2221 Cxx2bLoc = S->getBeginLoc();
2222 for (
Stmt *SubStmt : S->children()) {
2225 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2230 case Stmt::GCCAsmStmtClass:
2231 case Stmt::MSAsmStmtClass:
2233 case Stmt::CXXTryStmtClass:
2235 Cxx2aLoc = S->getBeginLoc();
2236 for (
Stmt *SubStmt : S->children()) {
2239 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2244 case Stmt::CXXCatchStmtClass:
2248 SemaRef, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,
2249 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2259 Cxx1yLoc = S->getBeginLoc();
2264 SemaRef.
Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
2265 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval();
2280 if (isa<CXXTryStmt>(Body)) {
2302 ? diag::ext_constexpr_function_try_block_cxx20
2303 : diag::warn_cxx17_compat_constexpr_function_try_block)
2304 << isa<CXXConstructorDecl>(Dcl);
2318 Cxx1yLoc, Cxx2aLoc, Cxx2bLoc,
Kind))
2329 }
else if (Cxx2bLoc.
isValid()) {
2332 ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
2333 : diag::ext_constexpr_body_invalid_stmt_cxx23)
2334 << isa<CXXConstructorDecl>(Dcl);
2335 }
else if (Cxx2aLoc.
isValid()) {
2338 ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
2339 : diag::ext_constexpr_body_invalid_stmt_cxx20)
2340 << isa<CXXConstructorDecl>(Dcl);
2341 }
else if (Cxx1yLoc.
isValid()) {
2344 ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
2345 : diag::ext_constexpr_body_invalid_stmt)
2346 << isa<CXXConstructorDecl>(Dcl);
2350 = dyn_cast<CXXConstructorDecl>(Dcl)) {
2359 if (Constructor->getNumCtorInitializers() == 0 &&
2365 ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
2366 : diag::ext_constexpr_union_ctor_no_init);
2371 }
else if (!Constructor->isDependentContext() &&
2372 !Constructor->isDelegatingConstructor()) {
2373 assert(RD->
getNumVBases() == 0 &&
"constexpr ctor with virtual bases");
2377 bool AnyAnonStructUnionMembers =
false;
2378 unsigned Fields = 0;
2380 E = RD->
field_end(); I != E; ++I, ++Fields) {
2381 if (I->isAnonymousStructOrUnion()) {
2382 AnyAnonStructUnionMembers =
true;
2390 if (AnyAnonStructUnionMembers ||
2391 Constructor->getNumCtorInitializers() != RD->
getNumBases() + Fields) {
2395 llvm::SmallSet<Decl*, 16> Inits;
2396 for (
const auto *I: Constructor->inits()) {
2400 Inits.insert(
ID->chain_begin(),
ID->chain_end());
2403 bool Diagnosed =
false;
2404 for (
auto *I : RD->
fields())
2411 if (ReturnStmts.empty()) {
2422 OK ? diag::warn_cxx11_compat_constexpr_body_no_return
2423 : diag::err_constexpr_body_no_return)
2437 }
else if (ReturnStmts.size() > 1) {
2443 ? diag::warn_cxx11_compat_constexpr_body_multiple_return
2444 : diag::ext_constexpr_body_multiple_return);
2445 for (
unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
2447 diag::note_constexpr_body_previous_return);
2476 diag::ext_constexpr_function_never_constant_expr)
2477 << isa<CXXConstructorDecl>(Dcl) << Dcl->
isConsteval()
2479 for (
size_t I = 0, N =
Diags.size(); I != N; ++I)
2497 Diag(it->second, diag::err_immediate_function_used_before_definition)
2510 "expected an immediate function");
2511 assert(FD->
hasBody() &&
"expected the function to have a body");
2512 struct ImmediateEscalatingExpressionsVisitor
2519 bool ImmediateFnIsConstructor;
2525 ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {}
2527 bool shouldVisitImplicitCode()
const {
return true; }
2528 bool shouldVisitLambdaBody()
const {
return false; }
2533 if (CurrentConstructor && CurrentInit) {
2541 SemaRef.
Diag(Loc, diag::note_immediate_function_reason)
2542 << ImmediateFn << Fn << Fn->
isConsteval() << IsCall
2543 << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
2544 << (InitializedField !=
nullptr)
2545 << (CurrentInit && !CurrentInit->
isWritten())
2546 << InitializedField << Range;
2548 bool TraverseCallExpr(
CallExpr *E) {
2549 if (
const auto *DR =
2551 DR && DR->isImmediateEscalating()) {
2557 if (!getDerived().TraverseStmt(A))
2564 if (
const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->
getDecl());
2566 Diag(E, ReferencedFn,
false);
2584 return Base::TraverseConstructorInitializer(Init);
2589 return Base::TraverseCXXConstructorDecl(Ctr);
2592 bool TraverseType(
QualType T) {
return true; }
2593 bool VisitBlockExpr(
BlockExpr *
T) {
return true; }
2595 } Visitor(*
this, FD);
2596 Visitor.TraverseDecl(FD);
2615 return dyn_cast_or_null<CXXRecordDecl>(DC);
2618 return dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2643 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
2645 CurDecl = dyn_cast_or_null<CXXRecordDecl>(
CurContext);
2665 for (
const auto &I : Current->bases()) {
2677 Queue.push_back(
Base);
2683 Current = Queue.pop_back_val();
2711 if (
Class->isUnion()) {
2712 Diag(
Class->getLocation(), diag::err_base_clause_on_union)
2719 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
2731 if (BaseDecl->getCanonicalDecl() ==
Class->getCanonicalDecl() ||
2732 ((BaseDecl = BaseDecl->getDefinition()) &&
2734 Diag(BaseLoc, diag::err_circular_inheritance)
2737 if (BaseDecl->getCanonicalDecl() !=
Class->getCanonicalDecl())
2738 Diag(BaseDecl->getLocation(), diag::note_previous_decl)
2751 if (!
Class->getTypeForDecl()->isDependentType())
2752 Class->setInvalidDecl();
2755 Access, TInfo, EllipsisLoc);
2760 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
2767 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
2775 if (
auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
2787 diag::err_incomplete_base_class, SpecifierRange)) {
2788 Class->setInvalidDecl();
2794 assert(BaseDecl &&
"Record type has no declaration");
2796 assert(BaseDecl &&
"Base type is not incomplete, but has no definition");
2798 assert(CXXBaseDecl &&
"Base type is not a C++ type");
2803 const auto *BaseCSA = CXXBaseDecl->
getAttr<CodeSegAttr>();
2804 const auto *DerivedCSA =
Class->getAttr<CodeSegAttr>();
2805 if ((DerivedCSA || BaseCSA) &&
2806 (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
2807 Diag(
Class->getLocation(), diag::err_mismatched_code_seg_base);
2808 Diag(CXXBaseDecl->
getLocation(), diag::note_base_class_specified_here)
2820 Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
2828 if (FinalAttr *FA = CXXBaseDecl->
getAttr<FinalAttr>()) {
2829 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
2831 << FA->isSpelledAsSealed();
2838 Class->setInvalidDecl();
2843 Access, TInfo, EllipsisLoc);
2865 Class->setIsParsingBaseSpecifiers();
2873 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
2874 << AL << AL.getRange();
2876 Diag(AL.getLoc(), diag::err_base_specifier_attribute)
2877 << AL << AL.isRegularKeywordAttribute() << AL.getRange();
2893 Class->setInvalidDecl();
2910 auto Decl = Rec->getAsCXXRecordDecl();
2913 for (
const auto &BaseSpec :
Decl->bases()) {
2934 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
2941 unsigned NumGoodBases = 0;
2942 bool Invalid =
false;
2943 for (
unsigned idx = 0; idx < Bases.size(); ++idx) {
2953 Diag(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)
2954 << KnownBase->
getType() << Bases[idx]->getSourceRange();
2963 KnownBase = Bases[idx];
2964 Bases[NumGoodBases++] = Bases[idx];
2969 if (Bases.size() > 1)
2974 if (
Class->isInterface() &&
2991 Class->setBases(Bases.data(), NumGoodBases);
2994 for (
unsigned idx = 0; idx < NumGoodBases; ++idx) {
2996 QualType BaseType = Bases[idx]->getType();
3006 if (IndirectBaseTypes.count(CanonicalBase)) {
3010 =
Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
3014 if (Paths.isAmbiguous(CanonicalBase))
3015 Diag(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)
3017 << Bases[idx]->getSourceRange();
3019 assert(Bases[idx]->isVirtual());
3035 if (!ClassDecl || Bases.empty())
3096 for (
unsigned I = Path.size(); I != 0; --I) {
3097 if (Path[I - 1].
Base->isVirtual()) {
3104 for (
unsigned I = Start, E = Path.size(); I != E; ++I)
3111 assert(BasePathArray.empty() &&
"Base path array must be empty!");
3112 assert(Paths.isRecordingPaths() &&
"Must record paths!");
3129 unsigned InaccessibleBaseID,
3130 unsigned AmbiguousBaseConvID,
3134 bool IgnoreAccess) {
3142 if (!DerivationOkay)
3147 Path = &Paths.front();
3154 if (PossiblePath.size() == 1) {
3155 Path = &PossiblePath;
3156 if (AmbiguousBaseConvID)
3157 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
3158 <<
Base << Derived << Range;
3165 if (!IgnoreAccess) {
3184 if (AmbiguousBaseConvID) {
3192 Paths.setRecordingPaths(
true);
3194 assert(StillOkay &&
"Can only be used with a derived-to-base conversion");
3203 Diag(Loc, AmbiguousBaseConvID)
3204 << Derived <<
Base << PathDisplayStr << Range << Name;
3213 bool IgnoreAccess) {
3215 Derived,
Base, diag::err_upcast_to_inaccessible_base,
3216 diag::err_ambiguous_derived_to_base_conv, Loc, Range,
DeclarationName(),
3217 BasePath, IgnoreAccess);
3234 std::string PathDisplayStr;
3235 std::set<unsigned> DisplayedPaths;
3237 Path != Paths.end(); ++Path) {
3238 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
3241 PathDisplayStr +=
"\n ";
3243 for (CXXBasePath::const_iterator Element = Path->begin();
3244 Element != Path->end(); ++Element)
3245 PathDisplayStr +=
" -> " + Element->Base->getType().getAsString();
3249 return PathDisplayStr;
3260 assert(Access !=
AS_none &&
"Invalid kind for syntactic access specifier!");
3290 if (!OverloadedMethods.empty()) {
3291 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3292 Diag(OA->getLocation(),
3293 diag::override_keyword_hides_virtual_member_function)
3294 <<
"override" << (OverloadedMethods.size() > 1);
3295 }
else if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3296 Diag(FA->getLocation(),
3297 diag::override_keyword_hides_virtual_member_function)
3298 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3299 << (OverloadedMethods.size() > 1);
3310 if (OverrideAttr *OA = D->
getAttr<OverrideAttr>()) {
3311 Diag(OA->getLocation(),
3312 diag::override_keyword_only_allowed_on_virtual_member_functions)
3316 if (FinalAttr *FA = D->
getAttr<FinalAttr>()) {
3317 Diag(FA->getLocation(),
3318 diag::override_keyword_only_allowed_on_virtual_member_functions)
3319 << (FA->isSpelledAsSealed() ?
"sealed" :
"final")
3331 if (MD->
hasAttr<OverrideAttr>() && !HasOverriddenMethods)
3332 Diag(MD->
getLocation(), diag::err_function_marked_override_not_overriding)
3352 auto EmitDiag = [&](
unsigned DiagInconsistent,
unsigned DiagSuggest) {
3361 if (isa<CXXDestructorDecl>(MD))
3363 diag::warn_inconsistent_destructor_marked_not_override_overriding,
3364 diag::warn_suggest_destructor_marked_not_override_overriding);
3366 EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,
3367 diag::warn_suggest_function_marked_not_override_overriding);
3376 FinalAttr *FA = Old->
getAttr<FinalAttr>();
3382 << FA->isSpelledAsSealed();
3391 return !RD->isCompleteDefinition() ||
3392 !RD->hasTrivialDefaultConstructor() ||
3393 !RD->hasTrivialDestructor();
3406 std::map<CXXRecordDecl*, NamedDecl*> Bases;
3409 const auto Base =
Specifier->getType()->getAsCXXRecordDecl();
3411 if (Bases.find(
Base) != Bases.end())
3413 for (
const auto Field :
Base->lookup(FieldName)) {
3414 if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
3417 assert(Bases.find(
Base) == Bases.end());
3430 for (
const auto &
P : Paths) {
3431 auto Base =
P.back().Base->getType()->getAsCXXRecordDecl();
3432 auto It = Bases.find(
Base);
3434 if (It == Bases.end())
3436 auto BaseField = It->second;
3437 assert(BaseField->getAccess() !=
AS_private);
3440 Diag(Loc, diag::warn_shadow_field)
3441 << FieldName << RD <<
Base << DeclIsField;
3442 Diag(BaseField->getLocation(), diag::note_shadow_field);
3467 Expr *BitWidth =
static_cast<Expr*
>(BW);
3476 if (cast<CXXRecordDecl>(
CurContext)->isInterface()) {
3480 unsigned InvalidDecl;
3481 bool ShowDeclName =
true;
3491 else switch (Name.getNameKind()) {
3494 ShowDeclName =
false;
3499 ShowDeclName =
false;
3514 Diag(Loc, diag::err_invalid_member_in_interface)
3515 << (InvalidDecl-1) << Name;
3517 Diag(Loc, diag::err_invalid_member_in_interface)
3518 << (InvalidDecl-1) <<
"";
3544 diag::err_storageclass_invalid_for_member);
3564 const char *PrevSpec;
3569 assert(!Failed &&
"Making a constexpr member const shouldn't fail");
3573 const char *PrevSpec;
3579 "This is the only DeclSpec that should fail to be applied");
3583 isInstField =
false;
3593 if (!Name.isIdentifier()) {
3594 Diag(Loc, diag::err_bad_variable_name)
3603 if (TemplateParameterLists.size()) {
3605 if (TemplateParams->
size()) {
3614 diag::err_template_member_noparams)
3653 if (MSPropertyAttr) {
3655 BitWidth, InitStyle, AS, *MSPropertyAttr);
3658 isInstField =
false;
3661 BitWidth, InitStyle, AS);
3666 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(
CurContext));
3674 if (
Member->isInvalidDecl()) {
3676 }
else if (isa<VarDecl>(
Member) || isa<VarTemplateDecl>(
Member)) {
3679 Diag(Loc, diag::err_static_not_bitfield)
3681 }
else if (isa<TypedefDecl>(
Member)) {
3683 Diag(Loc, diag::err_typedef_not_bitfield)
3688 Diag(Loc, diag::err_not_integral_type_bitfield)
3689 << Name << cast<ValueDecl>(
Member)->getType()
3694 Member->setInvalidDecl();
3699 NonTemplateMember = FunTmpl->getTemplatedDecl();
3701 NonTemplateMember = VarTmpl->getTemplatedDecl();
3707 if (NonTemplateMember !=
Member)
3713 if (
auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
3714 auto *TD = DG->getDeducedTemplate();
3717 if (AS != TD->getAccess() &&
3718 TD->getDeclContext()->getRedeclContext()->Equals(
3719 DG->getDeclContext()->getRedeclContext())) {
3720 Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
3721 Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
3724 for (
const auto *D : cast<CXXRecordDecl>(
CurContext)->decls()) {
3725 if (
const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
3726 LastAccessSpec = AccessSpec;
3728 assert(LastAccessSpec &&
"differing access with no access specifier");
3729 Diag(LastAccessSpec->
getBeginLoc(), diag::note_deduction_guide_access)
3740 ? FinalAttr::Keyword_sealed
3741 : FinalAttr::Keyword_final));
3751 assert((Name || isInstField) &&
"No identifier for non-field ?");
3761 auto DeclHasUnusedAttr = [](
const QualType &
T) {
3763 return TD->hasAttr<UnusedAttr>();
3765 return TDT->getDecl()->hasAttr<UnusedAttr>();
3773 !DeclHasUnusedAttr(FD->
getType()) &&
3787 Diag(Loc, diag::err_sycl_device_global_not_publicly_accessible)
3792 if (
auto Decl = dyn_cast<NamedDecl>(DC)) {
3795 Diag(Loc, diag::err_sycl_device_global_not_publicly_accessible)
3810 class UninitializedFieldVisitor
3815 llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
3818 llvm::SmallPtrSetImpl<QualType> &BaseClasses;
3833 UninitializedFieldVisitor(
Sema &S,
3834 llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
3835 llvm::SmallPtrSetImpl<QualType> &BaseClasses)
3836 : Inherited(S.
Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
3837 Constructor(nullptr), InitList(
false), InitListFieldDecl(nullptr) {}
3840 bool IsInitListMemberExprInitialized(
MemberExpr *ME,
3841 bool CheckReferenceOnly) {
3843 bool ReferenceField =
false;
3848 Fields.push_back(FD);
3850 ReferenceField =
true;
3856 if (CheckReferenceOnly && !ReferenceField)
3862 for (
const FieldDecl *FD : llvm::drop_begin(llvm::reverse(Fields)))
3865 for (
auto UsedIter = UsedFieldIndex.begin(),
3866 UsedEnd = UsedFieldIndex.end(),
3867 OrigIter = InitFieldIndex.begin(),
3868 OrigEnd = InitFieldIndex.end();
3869 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
3870 if (*UsedIter < *OrigIter)
3872 if (*UsedIter > *OrigIter)
3879 void HandleMemberExpr(
MemberExpr *ME,
bool CheckReferenceOnly,
3892 dyn_cast<MemberExpr>(
Base->IgnoreParenImpCasts())) {
3894 if (isa<VarDecl>(SubME->getMemberDecl()))
3897 if (
FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
3902 AllPODFields =
false;
3904 Base = SubME->getBase();
3907 if (!isa<CXXThisExpr>(
Base->IgnoreParenImpCasts())) {
3912 if (AddressOf && AllPODFields)
3918 while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
3919 BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
3922 if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
3932 if (!Decls.count(FoundVD))
3937 if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
3939 if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
3944 if (CheckReferenceOnly && !IsReference)
3948 unsigned diag = IsReference
3949 ? diag::warn_reference_field_is_uninit
3950 : diag::warn_field_is_uninit;
3954 diag::note_uninit_in_this_constructor)
3959 void HandleValue(
Expr *E,
bool AddressOf) {
3962 if (
MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3963 HandleMemberExpr(ME,
false ,
3969 Visit(CO->getCond());
3970 HandleValue(CO->getTrueExpr(), AddressOf);
3971 HandleValue(CO->getFalseExpr(), AddressOf);
3976 dyn_cast<BinaryConditionalOperator>(E)) {
3977 Visit(BCO->getCond());
3978 HandleValue(BCO->getFalseExpr(), AddressOf);
3983 HandleValue(OVE->getSourceExpr(), AddressOf);
3988 switch (BO->getOpcode()) {
3993 HandleValue(BO->getLHS(), AddressOf);
3994 Visit(BO->getRHS());
3997 Visit(BO->getLHS());
3998 HandleValue(BO->getRHS(), AddressOf);
4007 InitFieldIndex.push_back(0);
4008 for (
auto *Child : ILE->
children()) {
4009 if (
InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
4010 CheckInitListExpr(SubList);
4014 ++InitFieldIndex.back();
4016 InitFieldIndex.pop_back();
4025 DeclsToRemove.clear();
4032 InitListFieldDecl =
Field;
4033 InitFieldIndex.clear();
4034 CheckInitListExpr(ILE);
4048 HandleMemberExpr(ME,
true ,
false );
4057 Inherited::VisitImplicitCastExpr(E);
4063 if (
InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
4067 if (ICE->getCastKind() == CK_NoOp)
4068 ArgExpr = ICE->getSubExpr();
4069 HandleValue(ArgExpr,
false );
4072 Inherited::VisitCXXConstructExpr(E);
4077 if (isa<MemberExpr>(Callee)) {
4078 HandleValue(Callee,
false );
4084 Inherited::VisitCXXMemberCallExpr(E);
4090 HandleValue(E->
getArg(0),
false);
4094 Inherited::VisitCallExpr(E);
4100 if (isa<UnresolvedLookupExpr>(Callee))
4101 return Inherited::VisitCXXOperatorCallExpr(E);
4105 HandleValue(Arg->IgnoreParenImpCasts(),
false );
4115 DeclsToRemove.push_back(FD);
4118 HandleValue(E->
getLHS(),
false );
4123 Inherited::VisitBinaryOperator(E);
4133 HandleValue(ME->
getBase(),
true );
4138 Inherited::VisitUnaryOperator(E);
4148 static void DiagnoseUninitializedFields(
4168 for (
auto *I : RD->
decls()) {
4169 if (
auto *FD = dyn_cast<FieldDecl>(I)) {
4170 UninitializedFields.insert(FD);
4171 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
4172 UninitializedFields.insert(IFD->getAnonField());
4177 for (
const auto &I : RD->
bases())
4178 UninitializedBaseClasses.insert(I.getType().getCanonicalType());
4180 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4183 UninitializedFieldVisitor UninitializedChecker(
SemaRef,
4184 UninitializedFields,
4185 UninitializedBaseClasses);
4187 for (
const auto *FieldInit :
Constructor->inits()) {
4188 if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
4191 Expr *InitExpr = FieldInit->getInit();
4196 dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
4197 InitExpr =
Default->getExpr();
4201 UninitializedChecker.CheckInitializer(InitExpr, Constructor,
4202 FieldInit->getAnyMember(),
4203 FieldInit->getBaseClass());
4205 UninitializedChecker.CheckInitializer(InitExpr,
nullptr,
4206 FieldInit->getAnyMember(),
4207 FieldInit->getBaseClass());
4230 auto *ParamDecl = cast<NamedDecl>(Param.Param);
4231 if (ParamDecl->getDeclName())
4252 return ConstraintExpr;
4267 return Seq.Perform(*
this, Entity,
Kind, InitExpr);
4281 "must set init style when field is created");
4298 assert(Init.isUsable() &&
"Init should at least have a RecoveryExpr");
4304 if (!Init.isInvalid())
4306 if (Init.isInvalid()) {
4324 DirectBaseSpec =
nullptr;
4325 for (
const auto &
Base : ClassDecl->
bases()) {
4329 DirectBaseSpec = &
Base;
4337 VirtualBaseSpec =
nullptr;
4338 if (!DirectBaseSpec || !DirectBaseSpec->
isVirtual()) {
4347 Path != Paths.end(); ++Path) {
4348 if (Path->back().Base->isVirtual()) {
4349 VirtualBaseSpec = Path->back().Base;
4356 return DirectBaseSpec || VirtualBaseSpec;
4371 DS, IdLoc, InitList,
4390 DS, IdLoc, List, EllipsisLoc);
4399 explicit MemInitializerValidatorCCC(
CXXRecordDecl *ClassDecl)
4400 : ClassDecl(ClassDecl) {}
4402 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
4404 if (
FieldDecl *Member = dyn_cast<FieldDecl>(ND))
4405 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
4406 return isa<TypeDecl>(ND);
4411 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
4412 return std::make_unique<MemInitializerValidatorCCC>(*
this);
4426 llvm::find_if(Result, [
this](
const NamedDecl *Elem) {
4427 return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
4431 if (Found == Result.end())
4433 Diag(Loc, diag::err_using_placeholder_variable) << Name;
4438 if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
4449 for (
auto *D : ClassDecl->
lookup(MemberOrBase)) {
4450 if (isa<FieldDecl, IndirectFieldDecl>(D)) {
4453 if (IsPlaceholder && D->getDeclContext() == ND->
getDeclContext())
4458 return cast<ValueDecl>(D);
4459 ND = cast<ValueDecl>(D);
4497 = dyn_cast<CXXConstructorDecl>(ConstructorD);
4521 ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
4523 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
4525 <<
SourceRange(IdLoc, Init->getSourceRange().getEnd());
4533 if (TemplateTypeTy) {
4558 bool NotUnknownSpecialization =
false;
4561 NotUnknownSpecialization = !
Record->hasAnyDependentBases();
4563 if (!NotUnknownSpecialization) {
4588 auto *TempSpec = cast<TemplateSpecializationType>(
4589 UnqualifiedBase->getInjectedClassNameSpecialization());
4591 for (
auto const &
Base : ClassDecl->
bases()) {
4595 BaseTemplate->getTemplateName(), TN)) {
4596 Diag(IdLoc, diag::ext_unqualified_base_class)
4597 <<
SourceRange(IdLoc, Init->getSourceRange().getEnd());
4598 BaseType =
Base.getType();
4607 MemInitializerValidatorCCC CCC(ClassDecl);
4616 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4617 << MemberOrBase <<
true);
4624 DirectBaseSpec, VirtualBaseSpec)) {
4629 PDiag(diag::err_mem_init_not_member_or_class_suggest)
4630 << MemberOrBase <<
false,
4643 if (!TyD && BaseType.
isNull()) {
4644 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
4645 << MemberOrBase <<
SourceRange(IdLoc,Init->getSourceRange().getEnd());
4673 assert((DirectMember || IndirectMember) &&
4674 "Member must be a FieldDecl or IndirectFieldDecl");
4679 if (
Member->isInvalidDecl())
4683 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4684 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4685 }
else if (
InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
4686 Args =
MultiExprArg(InitList->getInits(), InitList->getNumInits());
4694 if (
Member->getType()->isDependentType() || Init->isTypeDependent()) {
4699 bool InitList =
false;
4700 if (isa<InitListExpr>(Init)) {
4712 IdLoc, Init->getBeginLoc(), Init->getEndLoc())
4736 Init = MemberInit.
get();
4756 return Diag(NameLoc, diag::err_delegating_ctor)
4758 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
4760 bool InitList =
true;
4762 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4764 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4773 NameLoc, Init->getBeginLoc(), Init->getEndLoc())
4781 cast<CXXConstructExpr>(DelegationInit.
get())->getConstructor()) &&
4782 "Delegating constructor with no target?");
4788 DelegationInit.
get(), InitRange.
getBegin(),
false);
4806 DelegationInit = Init;
4821 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
4841 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
4870 if (!DirectBaseSpec && !VirtualBaseSpec) {
4879 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
4891 InitRange.
getEnd(), EllipsisLoc);
4898 if (DirectBaseSpec && VirtualBaseSpec)
4899 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
4904 BaseSpec = VirtualBaseSpec;
4907 bool InitList =
true;
4909 if (
ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
4911 Args =
MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
4951 InitRange.
getEnd(), EllipsisLoc);
4961 TargetType, ExprLoc);
4981 bool IsInheritedVirtualBase,
4985 IsInheritedVirtualBase);
4989 switch (ImplicitInitKind) {
4995 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, std::nullopt);
5001 bool Moving = ImplicitInitKind ==
IIK_Move;
5002 ParmVarDecl *Param = Constructor->getParamDecl(0);
5008 Constructor->getLocation(), ParamType,
5023 BasePath.push_back(BaseSpec);
5025 CK_UncheckedDerivedToBase,
5033 BaseInit = InitSeq.
Perform(
SemaRef, InitEntity, InitKind, CopyCtorArg);
5056 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
5065 if (Field->isInvalidDecl())
5071 bool Moving = ImplicitInitKind ==
IIK_Move;
5072 ParmVarDecl *Param = Constructor->getParamDecl(0);
5079 Expr *MemberExprBase =
5094 MemberLookup.
addDecl(Indirect ? cast<ValueDecl>(Indirect)
5145 "Unhandled implicit init kind!");
5181 if (!Field->getParent()->isUnion()) {
5184 diag::err_uninitialized_member_in_ctor)
5185 << (
int)Constructor->isImplicit()
5187 << 0 << Field->getDeclName();
5188 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5194 diag::err_uninitialized_member_in_ctor)
5195 << (
int)Constructor->isImplicit()
5197 << 1 << Field->getDeclName();
5198 SemaRef.
Diag(Field->getLocation(), diag::note_declared_at);
5215 CXXMemberInit =
nullptr;
5220 struct BaseAndFieldInfo {
5223 bool AnyErrorsInInits;
5225 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
5227 llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
5230 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
5242 bool isImplicitCopyOrMove()
const {
5253 llvm_unreachable(
"Invalid ImplicitInitializerKind!");
5257 AllToInit.push_back(Init);
5266 bool isInactiveUnionMember(
FieldDecl *Field) {
5272 ActiveUnionMember.lookup(
Record->getCanonicalDecl()))
5273 return Active !=
Field->getCanonicalDecl();
5276 if (isImplicitCopyOrMove())
5281 if (
Field->hasInClassInitializer())
5285 if (!
Field->isAnonymousStructOrUnion())
5294 bool isWithinInactiveUnionMember(
FieldDecl *Field,
5297 return isInactiveUnionMember(Field);
5299 for (
auto *C : Indirect->
chain()) {
5301 if (Field && isInactiveUnionMember(Field))
5316 if (ArrayT->isZeroSize())
5319 T = ArrayT->getElementType();
5328 if (Field->isInvalidDecl())
5333 Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
5334 return Info.addFieldInitializer(Init);
5348 if (Info.isWithinInactiveUnionMember(Field, Indirect))
5351 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
5369 return Info.addFieldInitializer(Init);
5379 if (Info.AnyErrorsInInits)
5390 return Info.addFieldInitializer(Init);
5397 Constructor->setNumCtorInitializers(1);
5401 Constructor->setCtorInitializers(initializer);
5410 DiagnoseUninitializedFields(*
this, Constructor);
5417 if (Constructor->isDependentContext()) {
5420 if (!Initializers.empty()) {
5421 Constructor->setNumCtorInitializers(Initializers.size());
5424 memcpy(baseOrMemberInitializers, Initializers.data(),
5426 Constructor->setCtorInitializers(baseOrMemberInitializers);
5431 Constructor->setInvalidDecl();
5436 BaseAndFieldInfo Info(*
this, Constructor, AnyErrors);
5440 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
5444 bool HadError =
false;
5446 for (
unsigned i = 0; i < Initializers.size(); i++) {
5449 if (
Member->isBaseInitializer())
5452 Info.AllBaseFields[
Member->getAnyMember()->getCanonicalDecl()] =
Member;
5455 for (
auto *C : F->chain()) {
5458 Info.ActiveUnionMember.insert(std::make_pair(
5463 Info.ActiveUnionMember.insert(std::make_pair(
5471 for (
auto &I : ClassDecl->
bases()) {
5473 DirectVBases.insert(&I);
5477 for (
auto &VBase : ClassDecl->
vbases()) {
5479 = Info.AllBaseFields.lookup(VBase.getType()->getAs<
RecordType>())) {
5487 Diag(
Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
5488 << VBase.getType() << ClassDecl;
5492 Info.AllToInit.push_back(
Value);
5493 }
else if (!AnyErrors && !ClassDecl->
isAbstract()) {
5498 bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
5501 &VBase, IsInheritedVirtualBase,
5507 Info.AllToInit.push_back(CXXBaseInit);
5514 if (
Base.isVirtual())
5518 = Info.AllBaseFields.lookup(
Base.getType()->getAs<
RecordType>())) {
5519 Info.AllToInit.push_back(
Value);
5520 }
else if (!AnyErrors) {
5529 Info.AllToInit.push_back(CXXBaseInit);
5534 for (
auto *Mem : ClassDecl->
decls()) {
5535 if (
auto *F = dyn_cast<FieldDecl>(Mem)) {
5540 if (F->isUnnamedBitField())
5546 if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
5555 if (Info.isImplicitCopyOrMove())
5558 if (
auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
5559 if (F->getType()->isIncompleteArrayType()) {
5561 "Incomplete array type is not valid");
5573 unsigned NumInitializers = Info.AllToInit.size();
5574 if (NumInitializers > 0) {
5575 Constructor->setNumCtorInitializers(NumInitializers);
5578 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
5580 Constructor->setCtorInitializers(baseOrMemberInitializers);
5585 Constructor->getParent());
5595 for (
auto *Field : RD->
fields())
5600 IdealInits.push_back(Field->getCanonicalDecl());
5609 if (!
Member->isAnyMemberInitializer())
5612 return Member->getAnyMember()->getCanonicalDecl();
5618 if (
Previous->isAnyMemberInitializer())
5623 if (Current->isAnyMemberInitializer())
5624 Diag << 0 << Current->getAnyMember();
5626 Diag << 1 << Current->getTypeSourceInfo()->getType();
5632 if (Constructor->getDeclContext()->isDependentContext())
5637 bool ShouldCheckOrder =
false;
5638 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5641 Init->getSourceLocation())) {
5642 ShouldCheckOrder =
true;
5646 if (!ShouldCheckOrder)
5657 for (
const auto &VBase : ClassDecl->
vbases())
5661 for (
const auto &
Base : ClassDecl->
bases()) {
5662 if (
Base.isVirtual())
5668 for (
auto *Field : ClassDecl->
fields()) {
5669 if (Field->isUnnamedBitField())
5675 unsigned NumIdealInits = IdealInitKeys.size();
5676 unsigned IdealIndex = 0;
5685 for (
unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
5690 for (; IdealIndex != NumIdealInits; ++IdealIndex)
5691 if (InitKey == IdealInitKeys[IdealIndex])
5697 if (IdealIndex == NumIdealInits && InitIndex) {
5698 WarnIndexes.push_back(InitIndex);
5701 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
5702 if (InitKey == IdealInitKeys[IdealIndex])
5705 assert(IdealIndex < NumIdealInits &&
5706 "initializer not found in initializer list");
5708 CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);
5711 if (WarnIndexes.empty())
5715 llvm::sort(CorrelatedInitOrder, llvm::less_first());
5721 Inits[WarnIndexes.front() - 1]->getSourceLocation(),
5722 WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order
5723 : diag::warn_some_initializers_out_of_order);
5725 for (
unsigned I = 0; I < CorrelatedInitOrder.size(); ++I) {
5726 if (CorrelatedInitOrder[I].second == I)
5741 if (WarnIndexes.size() == 1) {
5743 Inits[WarnIndexes.front()]);
5749 for (
unsigned WarnIndex : WarnIndexes) {
5752 diag::note_initializer_out_of_order);
5759 bool CheckRedundantInit(
Sema &S,
5769 diag::err_multiple_mem_initialization)
5770 <<
Field->getDeclName()
5771 <<
Init->getSourceRange();
5773 const Type *BaseClass =
Init->getBaseClass();
5774 assert(BaseClass &&
"neither field nor base");
5776 diag::err_multiple_base_initialization)
5778 <<
Init->getSourceRange();
5786 typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
5787 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
5789 bool CheckRedundantUnionInit(
Sema &S,
5791 RedundantUnionMap &Unions) {
5796 while (
Parent->isAnonymousStructOrUnion() ||
Parent->isUnion()) {
5798 UnionEntry &En = Unions[
Parent];
5799 if (En.first && En.first != Child) {
5801 diag::err_multiple_mem_union_initialization)
5802 <<
Field->getDeclName()
5803 <<
Init->getSourceRange();
5804 S.
Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
5805 << 0 << En.second->getSourceRange();
5812 if (!
Parent->isAnonymousStructOrUnion())
5829 if (!ConstructorDecl)
5835 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5838 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
5845 llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
5848 RedundantUnionMap MemberUnions;
5850 bool HadError =
false;
5851 for (
unsigned i = 0; i < MemInits.size(); i++) {
5855 Init->setSourceOrder(i);
5857 if (Init->isAnyMemberInitializer()) {
5859 if (CheckRedundantInit(*
this, Init, Members[Key]) ||
5860 CheckRedundantUnionInit(*
this, Init, MemberUnions))
5862 }
else if (Init->isBaseInitializer()) {
5864 if (CheckRedundantInit(*
this, Init, Members[Key]))
5867 assert(Init->isDelegatingInitializer());
5869 if (MemInits.size() != 1) {
5870 Diag(Init->getSourceLocation(),
5871 diag::err_delegating_initializer_alone)
5872 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
5888 DiagnoseUninitializedFields(*
this, Constructor);
5905 for (
auto *Field : ClassDecl->
fields()) {
5906 if (Field->isInvalidDecl())
5933 PDiag(diag::err_access_dtor_field)
5934 << Field->getDeclName()
5943 bool VisitVirtualBases = !ClassDecl->
isAbstract();
5950 if (Dtor && Dtor->
isUsed())
5951 VisitVirtualBases =
false;
5957 for (
const auto &
Base : ClassDecl->
bases()) {
5963 if (
Base.isVirtual()) {
5964 if (!VisitVirtualBases)
5966 DirectVirtualBases.insert(RT);
5983 PDiag(diag::err_access_dtor_base)
5984 <<
Base.getType() <<
Base.getSourceRange(),
5991 if (VisitVirtualBases)
5993 &DirectVirtualBases);
5998 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {
6000 for (
const auto &VBase : ClassDecl->
vbases()) {
6005 if (DirectVirtualBases && DirectVirtualBases->count(RT))
6021 PDiag(diag::err_access_dtor_vbase)
6027 diag::err_access_dtor_vbase, 0, ClassDecl->
getLocation(),
6041 = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
6047 DiagnoseUninitializedFields(*
this, Constructor);
6102 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
6103 MEnd = FinalOverriders.end();
6107 SOEnd = M->second.end();
6108 SO != SOEnd; ++SO) {
6115 if (SO->second.size() != 1)
6118 if (!SO->second.front().Method->isPureVirtual())
6121 if (!SeenPureMethods.insert(SO->second.front().Method).second)
6124 Diag(SO->second.front().Method->getLocation(),
6125 diag::note_pure_virtual_function)
6126 << SO->second.front().Method->getDeclName() << RD->
getDeclName();
6136 struct AbstractUsageInfo {
6144 AbstractType(S.
Context.getCanonicalType(
6149 if (Invalid)
return;
6157 struct CheckAbstractUsage {
6158 AbstractUsageInfo &Info;
6161 CheckAbstractUsage(AbstractUsageInfo &Info,
const NamedDecl *Ctx)
6162 : Info(Info), Ctx(Ctx) {}
6166 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6167 #define TYPELOC(CLASS, PARENT) \
6168 case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
6169 #include "clang/AST/TypeLocNodes.def"
6175 for (
unsigned I = 0, E = TL.
getNumParams(); I != E; ++I) {
6190 for (
unsigned I = 0, E = TL.
getNumArgs(); I != E; ++I) {
6200 #define CheckPolymorphic(Type) \
6201 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
6202 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
6217 return Visit(Next, Sel);
6227 T = Info.S.Context.getBaseElementType(
T);
6230 if (CT != Info.AbstractType)
return;
6235 Info.S.Diag(Ctx->
getLocation(), diag::err_array_of_abstract_type)
6238 Info.S.Diag(Ctx->
getLocation(), diag::err_abstract_type_in_decl)
6241 Info.DiagnoseAbstractType();
6247 CheckAbstractUsage(*
this, D).Visit(TL, Sel);
6282 for (
auto *D : RD->
decls()) {
6283 if (D->isImplicit())
continue;
6286 if (
auto *FD = dyn_cast<FriendDecl>(D)) {
6287 D = FD->getFriendDecl();
6292 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
6294 }
else if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(D)) {
6298 }
else if (
auto *FD = dyn_cast<FieldDecl>(D)) {
6301 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
6303 }
else if (
auto *VTD = dyn_cast<VarTemplateDecl>(D)) {
6307 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
6309 }
else if (
auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
6320 assert(ClassAttr->
getKind() == attr::DLLExport);
6330 struct MarkingClassDllexported {
6341 ~MarkingClassDllexported() {
6351 if (!
Member->hasAttr<DLLExportAttr>())
6356 auto *VD = dyn_cast<VarDecl>(
Member);
6357 if (VD && VD->getStorageClass() ==
SC_Static &&
6361 auto *MD = dyn_cast<CXXMethodDecl>(
Member);
6365 if (MD->isUserProvided()) {
6375 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
6385 }
else if (MD->isExplicitlyDefaulted()) {
6394 }
else if (!MD->isTrivial() ||
6395 MD->isCopyAssignmentOperator() ||
6396 MD->isMoveAssignmentOperator()) {
6420 auto *CD = dyn_cast<CXXConstructorDecl>(
Member);
6421 if (!CD || !CD->isDefaultConstructor())
6423 auto *
Attr = CD->getAttr<DLLExportAttr>();
6429 if (!
Class->isDependentContext()) {
6436 if (LastExportedDefaultCtor) {
6438 diag::err_attribute_dll_ambiguous_default_ctor)
6440 S.
Diag(CD->getLocation(), diag::note_entity_declared_at)
6441 << CD->getDeclName();
6444 LastExportedDefaultCtor = CD;
6450 bool ErrorReported =
false;
6451 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6455 S.
Diag(TD->getLocation(),
6456 diag::err_cuda_device_builtin_surftex_cls_template)
6458 ErrorReported =
true;
6463 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6466 diag::err_cuda_device_builtin_surftex_ref_decl)
6469 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6473 TD = SD->getSpecializedTemplate();
6477 unsigned N = Params->
size();
6480 reportIllegalClassTemplate(S, TD);
6482 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6485 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6486 reportIllegalClassTemplate(S, TD);
6488 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6492 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6493 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6494 reportIllegalClassTemplate(S, TD);
6496 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6504 bool ErrorReported =
false;
6505 auto reportIllegalClassTemplate = [&ErrorReported](
Sema &S,
6509 S.
Diag(TD->getLocation(),
6510 diag::err_cuda_device_builtin_surftex_cls_template)
6512 ErrorReported =
true;
6517 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(
Class);
6520 diag::err_cuda_device_builtin_surftex_ref_decl)
6523 diag::note_cuda_device_builtin_surftex_should_be_template_class)
6527 TD = SD->getSpecializedTemplate();
6531 unsigned N = Params->
size();
6534 reportIllegalClassTemplate(S, TD);
6536 diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)
6539 if (N > 0 && !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
6540 reportIllegalClassTemplate(S, TD);
6542 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6546 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(1));
6547 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6548 reportIllegalClassTemplate(S, TD);
6550 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6555 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->
getParam(2));
6556 if (!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {
6557 reportIllegalClassTemplate(S, TD);
6559 diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)
6567 for (
auto *Method :
Class->methods()) {
6568 if (Method->isUserProvided())
6581 if (
auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(
Class)) {
6582 if (
Attr *TemplateAttr =
6583 getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
6584 auto *A = cast<InheritableAttr>(TemplateAttr->clone(
getASTContext()));
6585 A->setInherited(
true);
6600 (!
Class->isExternallyVisible() &&
Class->hasExternalFormalLinkage())) {
6601 Class->dropAttrs<DLLExportAttr, DLLImportAttr>();
6605 if (!
Class->isExternallyVisible()) {
6606 Diag(
Class->getLocation(), diag::err_attribute_dll_not_extern)
6607 <<
Class << ClassAttr;
6615 if (!isa<VarDecl>(
Member) && !isa<CXXMethodDecl>(
Member))
6622 diag::err_attribute_dll_member_of_dll_class)
6623 << MemberAttr << ClassAttr;
6624 Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
6625 Member->setInvalidDecl();
6629 if (
Class->getDescribedClassTemplate())
6634 const bool ClassExported = ClassAttr->
getKind() == attr::DLLExport;
6639 const bool PropagatedImport =
6641 cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();
6650 Class->dropAttr<DLLExportAttr>();
6684 auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
6693 (Ctor || isa<CXXDestructorDecl>(MD)) && MD->
isTrivial())
6700 if (VD && PropagatedImport)
6714 if (ClassExported) {
6726 Member->addAttr(NewAttr);
6736 "friend re-decl should not already have a DLLAttr");
6768 NewAttr->setInherited(
true);
6769 BaseTemplateSpec->
addAttr(NewAttr);
6773 if (
auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
6774 ImportAttr->setPropagatedToBaseTemplate();
6795 Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
6800 diag::note_template_class_explicit_specialization_was_here)
6801 << BaseTemplateSpec;
6804 diag::note_template_class_instantiation_was_here)
6805 << BaseTemplateSpec;
6818 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
6830 if (MD->isCopyAssignmentOperator())
6833 if (MD->isMoveAssignmentOperator())
6836 if (isa<CXXDestructorDecl>(FD))
6844 case OO_ExclaimEqual:
6856 case OO_GreaterEqual:
6879 cast<CXXConstructorDecl>(FD));
6897 llvm_unreachable(
"Invalid special member.");
6915 bool CopyCtorIsTrivial =
false, CopyCtorIsTrivialForCall =
false;
6916 bool DtorIsTrivialForCall =
false;
6927 CopyCtorIsTrivial =
true;
6929 CopyCtorIsTrivialForCall =
true;
6933 if (CD->isCopyConstructor() && !CD->isDeleted() &&
6934 !CD->isIneligibleOrNotSelected()) {
6935 if (CD->isTrivial())
6936 CopyCtorIsTrivial =
true;
6937 if (CD->isTrivialForCall())
6938 CopyCtorIsTrivialForCall =
true;
6946 DtorIsTrivialForCall =
true;
6948 if (!DD->isDeleted() && DD->isTrivialForCall())
6949 DtorIsTrivialForCall =
true;
6953 if (CopyCtorIsTrivialForCall && DtorIsTrivialForCall)
6967 uint64_t TypeSize = isAArch64 ? 128 : 64;
6969 if (CopyCtorIsTrivial &&
6979 bool HasNonDeletedCopyOrMove =
false;
6985 HasNonDeletedCopyOrMove =
true;
6992 HasNonDeletedCopyOrMove =
true;
7000 if (MD->isDeleted() || MD->isIneligibleOrNotSelected())
7003 auto *CD = dyn_cast<CXXConstructorDecl>(MD);
7004 if (CD && CD->isCopyOrMoveConstructor())
7005 HasNonDeletedCopyOrMove =
true;
7006 else if (!isa<CXXDestructorDecl>(MD))
7009 if (!MD->isTrivialForCall())
7013 return HasNonDeletedCopyOrMove;
7024 bool IssuedDiagnostic =
false;
7027 if (!IssuedDiagnostic) {
7029 IssuedDiagnostic =
true;
7031 S.
Diag(O->getLocation(), diag::note_overridden_virtual_function);
7034 return IssuedDiagnostic;
7048 if (
Record->isAbstract() && !
Record->isInvalidDecl()) {
7049 AbstractUsageInfo Info(*
this,
Record);
7056 if (!
Record->isInvalidDecl() && !
Record->isDependentType() &&
7057 !
Record->isAggregate() && !
Record->hasUserDeclaredConstructor() &&
7059 bool Complained =
false;
7060 for (
const auto *F :
Record->fields()) {
7061 if (F->hasInClassInitializer() || F->isUnnamedBitField())
7064 if (F->getType()->isReferenceType() ||
7065 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
7067 Diag(
Record->getLocation(), diag::warn_no_constructor_for_refconst)
7068 << llvm::to_underlying(
Record->getTagKind()) <<
Record;
7072 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
7073 << F->getType()->isReferenceType()
7074 << F->getDeclName();
7079 if (
Record->getIdentifier()) {
7092 if (((isa<FieldDecl>(D) || isa<UnresolvedUsingValueDecl>(D)) &&
7093 Record->hasUserDeclaredConstructor()) ||
7094 isa<IndirectFieldDecl>(D)) {
7095 Diag((*I)->getLocation(), diag::err_member_name_of_class)
7103 if (
Record->isPolymorphic() && !
Record->isDependentType()) {
7106 !
Record->hasAttr<FinalAttr>())
7111 if (
Record->isAbstract()) {
7112 if (FinalAttr *FA =
Record->getAttr<FinalAttr>()) {
7113 Diag(
Record->getLocation(), diag::warn_abstract_final_class)
7114 << FA->isSpelledAsSealed();
7120 if (!
Record->hasAttr<FinalAttr>()) {
7122 if (
const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
7123 Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
7124 << FA->isSpelledAsSealed()
7127 (FA->isSpelledAsSealed() ?
" sealed" :
" final"));
7129 diag::note_final_dtor_non_final_class_silence)
7136 if (
Record->hasAttr<TrivialABIAttr>())
7141 bool HasTrivialABI =
Record->hasAttr<TrivialABIAttr>();
7144 Record->setHasTrivialSpecialMemberForCall();
7154 auto CheckCompletedMemberFunction = [&](
CXXMethodDecl *MD) {
7165 MD->
isDeleted() ? diag::err_deleted_override
7166 : diag::err_non_deleted_override,
7170 if (MD->isDefaulted() && MD->isDeleted())
7179 MD->isConsteval() ? diag::err_consteval_override
7180 : diag::err_non_consteval_override,
7182 return MD->isConsteval() !=
V->isConsteval();
7184 if (MD->isDefaulted() && MD->isDeleted())
7191 auto CheckForDefaultedFunction = [&](
FunctionDecl *FD) ->
bool {
7192 if (!FD || FD->
isInvalidDecl() || !FD->isExplicitlyDefaulted())
7198 DefaultedSecondaryComparisons.push_back(FD);
7208 bool Incomplete = CheckForDefaultedFunction(M);
7211 if (
Record->isDependentType())
7217 if (!M->isImplicit() && !M->isUserProvided()) {
7221 Record->finishedDefaultedOrDeletedMember(M);
7222 M->setTrivialForCall(
7225 Record->setTrivialForCallFlags(M);
7234 M->isUserProvided()) {
7235 M->setTrivialForCall(HasTrivialABI);
7236 Record->setTrivialForCallFlags(M);
7239 if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
7240 M->hasAttr<DLLExportAttr>()) {
7246 M->dropAttr<DLLExportAttr>();
7248 if (M->hasAttr<DLLExportAttr>()) {
7258 M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods())
7262 CheckCompletedMemberFunction(M);
7271 CompleteMemberFunction(Dtor);
7273 bool HasMethodWithOverrideControl =
false,
7274 HasOverridingMethodWithoutOverrideControl =
false;
7275 for (
auto *D :
Record->decls()) {
7276 if (
auto *M = dyn_cast<CXXMethodDecl>(D)) {
7279 if (!
Record->isDependentType()) {
7284 if (M->hasAttr<OverrideAttr>())
7285 HasMethodWithOverrideControl =
true;
7286 else if (M->size_overridden_methods() > 0)
7287 HasOverridingMethodWithoutOverrideControl =
true;
7290 if (!isa<CXXDestructorDecl>(M))
7291 CompleteMemberFunction(M);
7292 }
else if (
auto *F = dyn_cast<FriendDecl>(D)) {
7293 CheckForDefaultedFunction(
7294 dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));
7298 if (HasOverridingMethodWithoutOverrideControl) {
7299 bool HasInconsistentOverrideControl = HasMethodWithOverrideControl;
7300 for (
auto *M :
Record->methods())
7305 for (
FunctionDecl *FD : DefaultedSecondaryComparisons) {
7309 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD))
7310 CheckCompletedMemberFunction(MD);
7328 Diag(
Record->getLocation(), diag::warn_cxx_ms_struct);
7334 bool ClangABICompat4 =
7342 if (
Record->getArgPassingRestrictions() !=
7344 Record->setArgPassingRestrictions(
7353 Record->setParamDestroyedInCallee(
true);
7354 else if (
Record->hasNonTrivialDestructor())
7355 Record->setParamDestroyedInCallee(CanPass);
7364 if (
Record->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())
7366 else if (
Record->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())
7384 unsigned LHSQuals = 0;
7387 LHSQuals = FieldQuals;
7389 unsigned RHSQuals = FieldQuals;
7411 llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
7417 : S(S), UseLoc(UseLoc) {
7418 bool DiagnosedMultipleConstructedBases =
false;
7424 for (
auto *D : Shadow->
redecls()) {
7425 auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
7426 auto *DNominatedBase = DShadow->getNominatedBaseClass();
7427 auto *DConstructedBase = DShadow->getConstructedBaseClass();
7429 InheritedFromBases.insert(
7430 std::make_pair(DNominatedBase->getCanonicalDecl(),
7431 DShadow->getNominatedBaseClassShadowDecl()));
7432 if (DShadow->constructsVirtualBase())
7433 InheritedFromBases.insert(
7434 std::make_pair(DConstructedBase->getCanonicalDecl(),
7435 DShadow->getConstructedBaseClassShadowDecl()));
7437 assert(DNominatedBase == DConstructedBase);
7442 if (!ConstructedBase) {
7443 ConstructedBase = DConstructedBase;
7444 ConstructedBaseIntroducer = D->getIntroducer();
7445 }
else if (ConstructedBase != DConstructedBase &&
7447 if (!DiagnosedMultipleConstructedBases) {
7448 S.
Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
7451 diag::note_ambiguous_inherited_constructor_using)
7453 DiagnosedMultipleConstructedBases =
true;
7455 S.
Diag(D->getIntroducer()->getLocation(),
7456 diag::note_ambiguous_inherited_constructor_using)
7457 << DConstructedBase;
7461 if (DiagnosedMultipleConstructedBases)
7468 std::pair<CXXConstructorDecl *, bool>
7470 auto It = InheritedFromBases.find(
Base->getCanonicalDecl());
7471 if (It == InheritedFromBases.end())
7472 return std::make_pair(
nullptr,
false);
7476 return std::make_pair(
7478 It->second->constructsVirtualBase());
7481 return std::make_pair(Ctor,
false);
7498 if (InheritedCtor) {
7501 Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
7503 return BaseCtor->isConstexpr();
7571 if (Ctor && ClassDecl->
isUnion())
7591 for (
const auto &B : ClassDecl->
bases()) {
7597 InheritedCtor, Inherited))
7610 for (
const auto *F : ClassDecl->
fields()) {
7611 if (F->isInvalidDecl())
7614 F->hasInClassInitializer())
7618 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7621 ConstArg && !F->isMutable()))
7636 struct ComputingExceptionSpec {
7647 ~ComputingExceptionSpec() {
7667 if (DFK.isSpecialMember())
7669 S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),
nullptr);
7670 if (DFK.isComparison())
7672 DFK.asComparison());
7674 auto *CD = cast<CXXConstructorDecl>(FD);
7675 assert(CD->getInheritedConstructor() &&
7676 "only defaulted functions and inherited constructors have implicit "
7679 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7706 auto ESI = IES.getExceptionSpec();
7738 "not an explicitly-defaulted special member");
7748 bool HadError =
false;
7761 bool ShouldDeleteForTypeMismatch =
false;
7762 unsigned ExpectedParams = 1;
7774 if (DeleteOnTypeMismatch)
7775 ShouldDeleteForTypeMismatch =
true;
7785 bool CanHaveConstParam =
false;
7795 ReturnType =
Type->getReturnType();
7806 Diag(MD->
getLocation(), diag::err_defaulted_special_member_return_type)
7808 << ExpectedReturnType;
7814 if (DeleteOnTypeMismatch)
7815 ShouldDeleteForTypeMismatch =
true;
7832 if (DeleteOnTypeMismatch)
7833 ShouldDeleteForTypeMismatch =
true;
7836 diag::err_defaulted_special_member_explicit_object_mismatch)
7849 bool HasConstParam =
false;
7856 if (DeleteOnTypeMismatch)
7857 ShouldDeleteForTypeMismatch =
true;
7860 diag::err_defaulted_special_member_volatile_param)
7861 << llvm::to_underlying(CSM);
7866 if (HasConstParam && !CanHaveConstParam) {
7867 if (DeleteOnTypeMismatch)
7868 ShouldDeleteForTypeMismatch =
true;
7872 diag::err_defaulted_special_member_copy_const_param)
7878 diag::err_defaulted_special_member_move_const_param)
7883 }
else if (ExpectedParams) {
7887 "unexpected non-ref argument");
7916 : isa<CXXConstructorDecl>(MD))) &&
7921 diag::err_incorrect_defaulted_constexpr_with_vb)
7922 << llvm::to_underlying(CSM);
7923 for (
const auto &I : RD->
vbases())
7924 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);
7943 if (!
Type->hasExceptionSpec()) {
7961 << llvm::to_underlying(CSM);
7962 if (ShouldDeleteForTypeMismatch) {
7964 << llvm::to_underlying(CSM);
7968 Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
7972 if (ShouldDeleteForTypeMismatch && !HadError) {
7974 diag::warn_cxx17_compat_defaulted_method_type_mismatch)
7975 << llvm::to_underlying(CSM);
7982 << llvm::to_underlying(CSM);
7983 assert(!ShouldDeleteForTypeMismatch &&
"deleted non-first decl");
8005 template<
typename Derived,
typename ResultList,
typename Result,
8007 class DefaultedComparisonVisitor {
8013 : S(S), RD(RD), FD(FD), DCK(DCK) {
8017 Fns.assign(Info->getUnqualifiedLookups().begin(),
8018 Info->getUnqualifiedLookups().end());
8022 ResultList visit() {
8031 llvm_unreachable(
"not a defaulted comparison");
8035 getDerived().visitSubobjects(Results, RD, ParamLvalType.
getQualifiers());
8040 Results.add(getDerived().visitExpandedSubobject(
8041 ParamLvalType, getDerived().getCompleteObject()));
8044 llvm_unreachable(
"");
8048 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
8059 if (Results.add(getDerived().visitSubobject(
8068 if (
Field->isUnnamedBitField())
8071 if (
Field->isAnonymousStructOrUnion()) {
8072 if (visitSubobjects(Results,
Field->getType()->getAsCXXRecordDecl(),
8080 if (
Field->isMutable())
8085 if (Results.add(getDerived().visitSubobject(
8086 FieldType, getDerived().getField(Field))))
8094 Result visitSubobject(
QualType Type, Subobject Subobj) {
8097 if (
auto *CAT = dyn_cast_or_null<ConstantArrayType>(AT))
8098 return getDerived().visitSubobjectArray(CAT->getElementType(),
8099 CAT->getSize(), Subobj);
8100 return getDerived().visitExpandedSubobject(
Type, Subobj);
8105 return getDerived().visitSubobject(
Type, Subobj);
8118 struct DefaultedComparisonInfo {
8123 static DefaultedComparisonInfo deleted() {
8124 DefaultedComparisonInfo
Deleted;
8129 bool add(
const DefaultedComparisonInfo &R) {
8139 struct DefaultedComparisonSubobject {
8147 class DefaultedComparisonAnalyzer
8148 :
public DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,
8149 DefaultedComparisonInfo,
8150 DefaultedComparisonInfo,
8151 DefaultedComparisonSubobject> {
8153 enum DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };
8156 DiagnosticKind Diagnose;
8159 using Base = DefaultedComparisonVisitor;
8160 using Result = DefaultedComparisonInfo;
8161 using Subobject = DefaultedComparisonSubobject;
8167 DiagnosticKind Diagnose = NoDiagnostics)
8168 :
Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
8177 if (Diagnose == ExplainDeleted) {
8181 return Result::deleted();
8184 return Base::visit();
8188 Subobject getCompleteObject() {
8189 return Subobject{Subobject::CompleteObject, RD, FD->
getLocation()};
8194 Base->getBaseTypeLoc()};
8198 return Subobject{Subobject::Member,
Field,
Field->getLocation()};
8201 Result visitExpandedSubobject(
QualType Type, Subobject Subobj) {
8206 if (Diagnose == ExplainDeleted) {
8207 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
8210 return Result::deleted();
8215 Expr *Args[] = {&Xi, &Xi};
8219 assert(OO !=
OO_None &&
"not an overloaded operator!");
8220 return visitBinaryOperator(OO, Args, Subobj);
8234 !SpaceshipCandidates));
8239 CandidateSet.exclude(FD);
8241 if (Args[0]->getType()->isOverloadableType())
8252 switch (CandidateSet.BestViableFunction(S, FD->
getLocation(), Best)) {
8260 !Best->RewriteKind) {
8261 if (Diagnose == ExplainDeleted) {
8262 if (Best->Function) {
8263 S.
Diag(Best->Function->getLocation(),
8264 diag::note_defaulted_comparison_not_rewritten_callee)
8267 assert(Best->Conversions.size() == 2 &&
8268 Best->Conversions[0].isUserDefined() &&
8269 "non-user-defined conversion from class to built-in "
8271 S.
Diag(Best->Conversions[0]
8272 .UserDefined.FoundConversionFunction.getDecl()
8274 diag::note_defaulted_comparison_not_rewritten_conversion)
8278 return Result::deleted();
8288 CXXRecordDecl *ArgClass = Args[0]->getType()->getAsCXXRecordDecl();
8289 if (ArgClass && Best->FoundDecl.getDecl() &&
8290 Best->FoundDecl.getDecl()->isCXXClassMember()) {
8291 QualType ObjectType = Subobj.Kind == Subobject::Member
8292 ? Args[0]->getType()
8295 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
8296 Diagnose == ExplainDeleted
8297 ? S.
PDiag(diag::note_defaulted_comparison_inaccessible)
8298 << FD << Subobj.Kind << Subobj.Decl
8300 return Result::deleted();
8303 bool NeedsDeducing =
8311 assert(!BestFD->isDeleted() &&
"wrong overload resolution result");
8313 if (Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {
8314 if (Subobj.Kind != Subobject::CompleteObject)
8315 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
8316 << Subobj.
Kind << Subobj.Decl;
8317 S.
Diag(BestFD->getLocation(),
8318 diag::note_defaulted_comparison_not_constexpr_here);
8320 return Result::deleted();
8322 R.Constexpr &= BestFD->isConstexpr();
8324 if (NeedsDeducing) {
8329 if (BestFD->getReturnType()->isUndeducedType() &&
8335 if (Diagnose == NoDiagnostics) {
8338 diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)
8339 << Subobj.
Kind << Subobj.Decl;
8342 diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)
8343 << Subobj.
Kind << Subobj.Decl;
8344 S.
Diag(BestFD->getLocation(),
8345 diag::note_defaulted_comparison_cannot_deduce_callee)
8346 << Subobj.
Kind << Subobj.Decl;
8348 return Result::deleted();
8351 BestFD->getCallResultType());
8353 if (Diagnose == ExplainDeleted) {
8354 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
8355 << Subobj.
Kind << Subobj.Decl
8356 << BestFD->getCallResultType().withoutLocalFastQualifiers();
8357 S.
Diag(BestFD->getLocation(),
8358 diag::note_defaulted_comparison_cannot_deduce_callee)
8359 << Subobj.
Kind << Subobj.Decl;
8361 return Result::deleted();
8363 R.Category = Info->Kind;
8366 QualType T = Best->BuiltinParamTypes[0];
8367 assert(
T == Best->BuiltinParamTypes[1] &&
8368 "builtin comparison for different types?");
8369 assert(Best->BuiltinParamTypes[2].isNull() &&
8370 "invalid builtin comparison");
8372 if (NeedsDeducing) {
8373 std::optional<ComparisonCategoryType> Cat =
8375 assert(Cat &&
"no category for builtin comparison?");
8386 if (Diagnose == ExplainDeleted) {
8389 Kind = OO == OO_EqualEqual ? 1 : 2;
8390 CandidateSet.NoteCandidates(
8392 Subobj.Loc, S.
PDiag(diag::note_defaulted_comparison_ambiguous)
8393 << FD <<
Kind << Subobj.Kind << Subobj.Decl),
8396 R = Result::deleted();
8400 if (Diagnose == ExplainDeleted) {
8403 !Best->RewriteKind) {
8404 S.
Diag(Best->Function->getLocation(),
8405 diag::note_defaulted_comparison_not_rewritten_callee)
8409 diag::note_defaulted_comparison_calls_deleted)
8410 << FD << Subobj.
Kind << Subobj.Decl;
8414 R = Result::deleted();
8420 if (OO == OO_Spaceship &&
8424 if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,
8426 R.add(visitBinaryOperator(OO_Less, Args, Subobj, &CandidateSet));
8430 if (Diagnose == ExplainDeleted) {
8431 S.
Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
8432 << FD << (OO == OO_EqualEqual || OO == OO_ExclaimEqual)
8433 << Subobj.
Kind << Subobj.Decl;
8437 if (SpaceshipCandidates) {
8438 SpaceshipCandidates->NoteCandidates(
8443 diag::note_defaulted_comparison_no_viable_function_synthesized)
8444 << (OO == OO_EqualEqual ? 0 : 1);
8447 CandidateSet.NoteCandidates(
8452 R = Result::deleted();
8461 struct StmtListResult {
8462 bool IsInvalid =
false;
8466 IsInvalid |= S.isInvalid();
8469 Stmts.push_back(S.get());
8476 class DefaultedComparisonSynthesizer
8477 :
public DefaultedComparisonVisitor<DefaultedComparisonSynthesizer,
8478 StmtListResult, StmtResult,
8479 std::pair<ExprResult, ExprResult>> {
8481 unsigned ArrayDepth = 0;
8484 using Base = DefaultedComparisonVisitor;
8485 using ExprPair = std::pair<ExprResult, ExprResult>;
8492 :
Base(S, RD, FD, DCK), Loc(BodyLoc) {}
8498 StmtListResult Stmts = visit();
8499 if (Stmts.IsInvalid)
8505 llvm_unreachable(
"not a defaulted comparison");
8516 auto OldStmts = std::move(Stmts.Stmts);
8517 Stmts.Stmts.clear();
8520 auto FinishCmp = [&] {
8521 if (
Expr *Prior = CmpSoFar.
get()) {
8523 if (RetVal.
isUnset() && Stmts.Stmts.empty())
8526 else if (Stmts.add(buildIfNotCondReturnFalse(Prior)))
8532 for (
Stmt *EAsStmt : llvm::reverse(OldStmts)) {
8533 Expr *E = dyn_cast<Expr>(EAsStmt);
8536 if (FinishCmp() || Stmts.add(EAsStmt))
8551 std::reverse(Stmts.Stmts.begin(), Stmts.Stmts.end());
8569 RetVal = getDecl(EqualVD);
8572 RetVal = buildStaticCastToR(RetVal.
get());
8578 RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
8604 ExprPair getCompleteObject() {
8607 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD);
8622 ExprPair Obj = getCompleteObject();
8623 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8633 ExprPair Obj = getCompleteObject();
8634 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8657 assert(!False.
isInvalid() &&
"should never fail");
8659 if (ReturnFalse.isInvalid())
8677 llvm::raw_svector_ostream OS(Str);
8678 OS <<
"i" << ArrayDepth;
8689 auto IterRef = [&] {
8693 assert(!Ref.
isInvalid() &&
"can't reference our own variable?");
8699 Loc, BO_NE, IterRef(),
8701 assert(!Cond.
isInvalid() &&
"should never fail");
8705 assert(!
Inc.isInvalid() &&
"should never fail");
8713 Subobj.first = Index(Subobj.first);
8714 Subobj.second = Index(Subobj.second);
8721 if (Substmt.isInvalid())
8727 if (
Expr *ElemCmp = dyn_cast<Expr>(Substmt.get())) {
8729 "should have non-expression statement");
8730 Substmt = buildIfNotCondReturnFalse(ElemCmp);
8731 if (Substmt.isInvalid())
8744 if (Obj.first.isInvalid() || Obj.second.isInvalid())
8752 Obj.second.get(),
true,
8761 llvm_unreachable(
"not a defaulted comparison");
8776 Op = buildStaticCastToR(Op.
get());
8801 if (
Comp.isInvalid())
8809 VDRef = getDecl(VD);
8828 llvm_unreachable(
"");
8834 assert(!R->
isUndeducedType() &&
"type should have been deduced already");
8852 Self.LookupOverloadedOperatorName(OO, S, Operators);
8865 if (Op == OO_Spaceship) {
8866 Lookup(OO_ExclaimEqual);
8868 Lookup(OO_EqualEqual);
8896 bool IsMethod = isa<CXXMethodDecl>(FD);
8898 auto *MD = cast<CXXMethodDecl>(FD);
8899 assert(!MD->
isStatic() &&
"comparison function cannot be a static member");
8909 FPT->getParamTypes(), EPI));
8916 if (!
T.isConstQualified()) {
8925 InsertLoc = Loc.getRParenLoc();
8930 Diag(Loc, diag::err_defaulted_comparison_non_const)
8939 FPT->getParamTypes(), EPI));
8950 FPT->getParamTypes(), EPI));
8956 (IsMethod ? 1 : 2)) {
8960 <<
int(IsMethod) <<
int(DCK);
8966 if (Param->isExplicitObjectParameter())
8968 QualType ParmTy = Param->getType();
8973 bool Ok = !IsMethod;
8978 CTy = Ref->getPointeeType();
8989 }
else if (
auto *CRD = CTy->getAsRecordDecl()) {
8990 RD = cast<CXXRecordDecl>(CRD);
9006 <<
int(DCK) << ParmTy << RefTy <<
int(!IsMethod) << PlainTy
9007 << Param->getSourceRange();
9009 assert(!IsMethod &&
"should know expected type for method");
9011 diag::err_defaulted_comparison_param_unknown)
9012 <<
int(DCK) << ParmTy << Param->getSourceRange();
9018 Diag(FD->
getLocation(), diag::err_defaulted_comparison_param_mismatch)
9020 << ParmTy << Param->getSourceRange();
9025 assert(RD &&
"must have determined class");
9034 diag::err_defaulted_comparison_not_friend,
int(DCK),
9039 return FD->getCanonicalDecl() ==
9040 F->getFriendDecl()->getCanonicalDecl();
9043 <<
int(DCK) <<
int(0) << RD;
9055 Diag(FD->
getLocation(), diag::err_defaulted_comparison_return_type_not_bool)
9065 RT->getContainedDeducedType() &&
9067 RT->getContainedAutoType()->isConstrained())) {
9069 diag::err_defaulted_comparison_deduced_return_type_not_auto)
9081 DefaultedComparisonInfo Info =
9082 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK).visit();
9096 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9097 DefaultedComparisonAnalyzer::ExplainDeleted)
9108 diag::note_previous_declaration);
9120 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9121 DefaultedComparisonAnalyzer::ExplainDeleted)
9171 Diag(FD->
getBeginLoc(), diag::err_defaulted_comparison_constexpr_mismatch)
9173 DefaultedComparisonAnalyzer(*
this, RD, FD, DCK,
9174 DefaultedComparisonAnalyzer::ExplainConstexpr)
9195 EPI.ExceptionSpec.SourceDecl = FD;
9197 FPT->getParamTypes(), EPI));
9212 EqualEqual->setImplicit();
9227 Scope.addContextNote(UseLoc);
9234 CXXRecordDecl *RD = PT.getNonReferenceType()->getAsCXXRecordDecl();
9238 DefaultedComparisonSynthesizer(*
this, RD, FD, DCK, BodyLoc).build();
9252 L->CompletedImplicitDefinition(FD);
9259 ComputingExceptionSpec CES(S, FD, Loc);
9286 DefaultedComparisonSynthesizer(S, RD, FD, DCK, BodyLoc).build();
9287 if (!Body.isInvalid())
9308 for (
auto &Check : Overriding)
9320 template<
typename Derived>
9321 struct SpecialMemberVisitor {
9328 bool IsConstructor =
false, IsAssignment =
false, ConstArg =
false;
9332 : S(S), MD(MD), CSM(CSM), ICI(ICI) {
9337 IsConstructor =
true;
9341 IsAssignment =
true;
9346 llvm_unreachable(
"invalid special member kind");
9352 ConstArg = RT->getPointeeType().isConstQualified();
9356 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
9359 bool isMove()
const {
9366 unsigned Quals,
bool IsMutable) {
9368 ConstArg && !IsMutable);
9378 cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
9385 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
9392 return B->getBaseTypeLoc();
9394 return Subobj.get<
FieldDecl*>()->getLocation();
9399 VisitNonVirtualBases,
9404 VisitPotentiallyConstructedBases,
9410 bool visit(BasesToVisit Bases) {
9413 if (Bases == VisitPotentiallyConstructedBases)
9414 Bases = RD->
isAbstract() ? VisitNonVirtualBases : VisitAllBases;
9416 for (
auto &B : RD->
bases())
9417 if ((Bases == VisitDirectBases || !B.isVirtual()) &&
9418 getDerived().visitBase(&B))
9421 if (Bases == VisitAllBases)
9422 for (
auto &B : RD->
vbases())
9423 if (getDerived().visitBase(&B))
9426 for (
auto *F : RD->
fields())
9427 if (!F->isInvalidDecl() && !F->isUnnamedBitField() &&
9428 getDerived().visitField(F))
9437 struct SpecialMemberDeletionInfo
9438 : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
9443 bool AllFieldsAreConst;
9448 : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
9449 Loc(MD->getLocation()), AllFieldsAreConst(
true) {}
9460 bool visitField(
FieldDecl *Field) {
return shouldDeleteForField(Field); }
9463 bool shouldDeleteForField(
FieldDecl *FD);
9464 bool shouldDeleteForAllConstMembers();
9466 bool shouldDeleteForClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
9468 bool shouldDeleteForSubobjectCall(Subobject Subobj,
9470 bool IsDtorCallInCtor);
9478 bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
9499 bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
9501 bool IsDtorCallInCtor) {
9508 DiagKind = !
Decl ? 0 : 1;
9511 else if (!isAccessible(Subobj,
Decl))
9513 else if (!IsDtorCallInCtor && Field &&
Field->getParent()->isUnion() &&
9514 !
Decl->isTrivial()) {
9526 const auto *RD = cast<CXXRecordDecl>(
Field->getParent());
9540 diag::note_deleted_special_member_class_subobject)
9541 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9542 <<
true <<
Field << DiagKind << IsDtorCallInCtor
9547 diag::note_deleted_special_member_class_subobject)
9548 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9549 <<
false <<
Base->getType() << DiagKind
9550 << IsDtorCallInCtor <<
false;
9563 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
9566 bool IsMutable =
Field &&
Field->isMutable();
9583 Field->hasInClassInitializer()) &&
9584 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
9591 if (IsConstructor) {
9594 false,
false,
false,
false);
9595 if (shouldDeleteForSubobjectCall(Subobj, SMOR,
true))
9602 bool SpecialMemberDeletionInfo::shouldDeleteForVariantObjCPtrMember(
9617 auto *ParentClass = cast<CXXRecordDecl>(FD->
getParent());
9618 S.
Diag(FD->
getLocation(), diag::note_deleted_special_member_class_subobject)
9619 << llvm::to_underlying(getEffectiveCSM()) << ParentClass
9620 <<
true << FD << 4 <<
false
9638 if (
auto *BaseCtor = SMOR.
getMethod()) {
9643 if (BaseCtor->isDeleted() && Diagnose) {
9645 diag::note_deleted_special_member_class_subobject)
9646 << llvm::to_underlying(getEffectiveCSM()) << MD->
getParent()
9647 <<
false <<
Base->getType() << 1
9651 return BaseCtor->isDeleted();
9653 return shouldDeleteForClassSubobject(BaseClass,
Base, 0);
9658 bool SpecialMemberDeletionInfo::shouldDeleteForField(
FieldDecl *FD) {
9662 if (inUnion() && shouldDeleteForVariantObjCPtrMember(FD, FieldType))
9670 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9671 << !!ICI << MD->
getParent() << FD << FieldType << 0;
9681 S.
Diag(FD->
getLocation(), diag::note_deleted_default_ctor_uninit_field)
9687 AllFieldsAreConst =
false;
9693 S.
Diag(FD->
getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
9697 }
else if (IsAssignment) {
9702 << isMove() << MD->
getParent() << FD << FieldType << 0;
9717 if (!inUnion() && FieldRecord->
isUnion() &&
9719 bool AllVariantFieldsAreConst =
true;
9722 for (
auto *UI : FieldRecord->
fields()) {
9725 if (shouldDeleteForVariantObjCPtrMember(&*UI, UnionFieldType))
9729 AllVariantFieldsAreConst =
false;
9732 if (UnionFieldRecord &&
9733 shouldDeleteForClassSubobject(UnionFieldRecord, UI,
9740 AllVariantFieldsAreConst && !FieldRecord->
field_empty()) {
9743 diag::note_deleted_default_ctor_all_const)
9754 if (shouldDeleteForClassSubobject(FieldRecord, FD,
9765 bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
9769 AllFieldsAreConst) {
9770 bool AnyFields =
false;
9772 if ((AnyFields = !F->isUnnamedBitField()))
9778 diag::note_deleted_default_ctor_all_const)
9831 bool DeletesOnlyMatchingCopy =
9836 (!DeletesOnlyMatchingCopy ||
9838 if (!Diagnose)
return true;
9841 for (
auto *I : RD->
ctors()) {
9842 if (I->isMoveConstructor()) {
9843 UserDeclaredMove = I;
9847 assert(UserDeclaredMove);
9849 (!DeletesOnlyMatchingCopy ||
9851 if (!Diagnose)
return true;
9854 for (
auto *I : RD->
methods()) {
9855 if (I->isMoveAssignmentOperator()) {
9856 UserDeclaredMove = I;
9860 assert(UserDeclaredMove);
9863 if (UserDeclaredMove) {
9865 diag::note_deleted_copy_user_declared_move)
9883 OperatorDelete,
false)) {
9890 SpecialMemberDeletionInfo SMI(*
this, MD, CSM, ICI, Diagnose);
9898 if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
9899 : SMI.VisitPotentiallyConstructedBases))
9902 if (SMI.shouldDeleteForAllConstMembers())
9918 SMI.ConstArg, Diagnose);
9926 assert(DFK &&
"not a defaultable function");
9933 DefaultedComparisonAnalyzer(
9935 DFK.
asComparison(), DefaultedComparisonAnalyzer::ExplainDeleted)
9957 *Selected =
nullptr;
9961 llvm_unreachable(
"not a special member");
9979 for (
auto *CI : RD->
ctors()) {
9980 if (!CI->isDefaultConstructor())
9987 *Selected = DefCtor;
10020 }
else if (!Selected) {
10028 goto NeedOverloadResolution;
10038 }
else if (!Selected) {
10043 goto NeedOverloadResolution;
10047 NeedOverloadResolution:
10076 llvm_unreachable(
"unknown special method kind");
10080 for (
auto *CI : RD->
ctors())
10081 if (!CI->isImplicit())
10085 typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
10088 dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
10119 ConstRHS, TAH, Diagnose ? &Selected :
nullptr))
10127 S.
Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
10130 S.
Diag(CD->getLocation(), diag::note_user_declared_ctor);
10131 }
else if (!Selected)
10132 S.
Diag(SubobjLoc, diag::note_nontrivial_no_copy)
10140 S.
Diag(SubobjLoc, diag::note_nontrivial_user_provided)
10146 S.
Diag(SubobjLoc, diag::note_nontrivial_subobject)
10164 for (
const auto *FI : RD->
fields()) {
10165 if (FI->isInvalidDecl() || FI->isUnnamedBitField())
10171 if (FI->isAnonymousStructOrUnion()) {
10173 CSM, ConstArg, TAH, Diagnose))
10183 FI->hasInClassInitializer()) {
10185 S.
Diag(FI->getLocation(), diag::note_nontrivial_default_member_init)
10196 S.
Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
10201 bool ConstRHS = ConstArg && !FI->isMutable();
10229 "not special enough");
10233 bool ConstArg =
false;
10261 ClangABICompat14)) {
10291 llvm_unreachable(
"not a special member");
10297 diag::note_nontrivial_default_arg)
10316 for (
const auto &BI : RD->
bases())
10358 Diag(BS.
getBeginLoc(), diag::note_nontrivial_has_virtual) << RD << 1;
10363 for (
const auto *MI : RD->
methods()) {
10364 if (MI->isVirtual()) {
10366 Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
10371 llvm_unreachable(
"dynamic class with no vbases and no virtual functions");
10379 struct FindHiddenVirtualMethod {
10387 static bool CheckMostOverridenMethods(
10389 const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
10393 if (CheckMostOverridenMethods(O, Methods))
10409 bool foundSameNameMethod =
false;
10416 foundSameNameMethod =
true;
10433 if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
10434 overloadedMethods.push_back(MD);
10438 if (foundSameNameMethod)
10439 OverloadedMethods.append(overloadedMethods.begin(),
10440 overloadedMethods.end());
10441 return foundSameNameMethod;
10448 llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
10466 FindHiddenVirtualMethod FHVM;
10477 ND = shad->getTargetDecl();
10483 OverloadedMethods = FHVM.OverloadedMethods;
10488 for (
unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
10491 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
10508 if (!OverloadedMethods.empty()) {
10510 << MD << (OverloadedMethods.size() > 1);
10517 auto PrintDiagAndRemoveAttr = [&](
unsigned N) {
10520 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10521 diag::ext_cannot_use_trivial_abi) << &RD;
10522 Diag(RD.
getAttr<TrivialABIAttr>()->getLocation(),
10523 diag::note_cannot_use_trivial_abi_reason) << &RD << N;
10529 auto HasNonDeletedCopyOrMoveConstructor = [&]() {
10541 if (CD->isCopyOrMoveConstructor() && !CD->isDeleted())
10546 if (!HasNonDeletedCopyOrMoveConstructor()) {
10547 PrintDiagAndRemoveAttr(0);
10553 PrintDiagAndRemoveAttr(1);
10557 for (
const auto &B : RD.
bases()) {
10560 if (!B.getType()->isDependentType() &&
10561 !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) {
10562 PrintDiagAndRemoveAttr(2);
10566 if (B.isVirtual()) {
10567 PrintDiagAndRemoveAttr(3);
10572 for (
const auto *FD : RD.
fields()) {
10577 PrintDiagAndRemoveAttr(4);
10582 if (!RT->isDependentType() &&
10583 !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
10584 PrintDiagAndRemoveAttr(5);
10599 if (AL.getKind() != ParsedAttr::AT_Visibility)
10602 Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;
10610 LBrac, RBrac, AttrList);
10627 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Friend->getFriendDecl());
10632 Spaceships.clear();
10638 Spaceships.push_back(FD);
10647 if (
auto *FD = dyn_cast<FunctionDecl>(ND))
10648 if (FD->isExplicitlyDefaulted())
10649 Spaceships.push_back(FD);
10749 DefaultedSpaceships);
10750 for (
auto *FD : DefaultedSpaceships)
10757 llvm::function_ref<
Scope *()> EnterScope) {
10765 DeclContext *LookupDC = dyn_cast<DeclContext>(D);
10768 for (
unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
10769 ParameterLists.push_back(DD->getTemplateParameterList(i));
10773 ParameterLists.push_back(FTD->getTemplateParameters());
10774 }
else if (
VarDecl *VD = dyn_cast<VarDecl>(D)) {
10778 ParameterLists.push_back(VTD->getTemplateParameters());
10779 else if (
auto *PSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
10780 ParameterLists.push_back(PSD->getTemplateParameters());
10782 }
else if (
TagDecl *TD = dyn_cast<TagDecl>(D)) {
10783 for (
unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
10784 ParameterLists.push_back(TD->getTemplateParameterList(i));
10788 ParameterLists.push_back(CTD->getTemplateParameters());
10789 else if (
auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
10790 ParameterLists.push_back(PSD->getTemplateParameters());
10795 unsigned Count = 0;
10796 Scope *InnermostTemplateScope =
nullptr;
10800 if (Params->size() == 0)
10803 InnermostTemplateScope = EnterScope();
10805 if (Param->getDeclName()) {
10806 InnermostTemplateScope->
AddDecl(Param);
10814 if (InnermostTemplateScope) {
10815 assert(LookupDC &&
"no enclosing DeclContext for template lookup");
10823 if (!RecordD)
return;
10830 if (!RecordD)
return;
10904 bool DiagOccured =
false;
10906 [DiagID, &S, &DiagOccured](
DeclSpec::TQ, StringRef QualName,
10913 DiagOccured =
true;
10991 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
10993 return Constructor->setInvalidDecl();
11000 if (!Constructor->isInvalidDecl() &&
11001 Constructor->hasOneParamOrDefaultArgs() &&
11002 Constructor->getTemplateSpecializationKind() !=
11004 QualType ParamType = Constructor->getParamDecl(0)->getType();
11007 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
11008 const char *ConstRef
11009 = Constructor->getParamDecl(0)->getIdentifier() ?
"const &"
11011 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
11016 Constructor->setInvalidDecl();
11027 if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
11030 if (!Destructor->isImplicit())
11031 Loc = Destructor->getLocation();
11038 Expr *ThisArg =
nullptr;
11043 if (OperatorDelete->isDestroyingOperatorDelete()) {
11044 QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
11051 ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
11052 assert(!
This.isInvalid() &&
"couldn't form 'this' expr in dtor?");
11054 if (
This.isInvalid()) {
11057 Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
11060 ThisArg =
This.get();
11066 Destructor->setOperatorDelete(OperatorDelete, ThisArg);
11089 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
11092 if (TST->isTypeAlias())
11094 << DeclaratorType << 1;
11188 if (
After.isInvalid())
11247 unsigned NumParam = Proto->getNumParams();
11251 if (NumParam == 1) {
11253 if (
const auto *
First =
11254 dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param);
11255 First &&
First->isExplicitObjectParameter())
11259 if (NumParam != 0) {
11264 }
else if (Proto->isVariadic()) {
11271 if (Proto->getReturnType() != ConvType) {
11272 bool NeedsTypedef =
false;
11276 bool PastFunctionChunk =
false;
11278 switch (Chunk.Kind) {
11280 if (!PastFunctionChunk) {
11281 if (Chunk.Fun.HasTrailingReturnType) {
11286 PastFunctionChunk =
true;
11291 NeedsTypedef =
true;
11313 auto &&DB =
Diag(Loc, diag::err_conv_function_with_complex_decl);
11314 DB << Before <<
After;
11316 if (!NeedsTypedef) {
11320 if (
After.isInvalid() && ConvTSI) {
11328 }
else if (!Proto->getReturnType()->isDependentType()) {
11329 DB << 1 << Proto->getReturnType();
11331 DB << 2 << Proto->getReturnType();
11342 ConvType = Proto->getReturnType();
11363 Proto->getExtProtoInfo());
11369 ? diag::warn_cxx98_compat_explicit_conversion_functions
11370 : diag::ext_explicit_conversion_functions)
11379 assert(Conversion &&
"Expected to receive a conversion function declaration");
11402 if (ConvType == ClassType)
11407 << ClassType << ConvType;
11410 << ClassType << ConvType;
11425 return ConversionTemplate;
11450 for (
unsigned Idx = 0; Idx < FTI.
NumParams; Idx++) {
11451 const auto &ParamInfo = FTI.
Params[Idx];
11452 if (!ParamInfo.Param)
11454 ParmVarDecl *Param = cast<ParmVarDecl>(ParamInfo.Param);
11458 ExplicitObjectParam = Param;
11462 diag::err_explicit_object_parameter_must_be_first)
11466 if (!ExplicitObjectParam)
11471 diag::err_explicit_object_default_arg)
11479 diag::err_explicit_object_parameter_nonmember)
11486 diag::err_explicit_object_parameter_nonmember)
11493 diag::err_explicit_object_parameter_mutable)
11502 diag::err_explicit_object_parameter_nonmember)
11512 diag::err_explicit_object_parameter_constructor)
11522 struct BadSpecifierDiagnoser {
11525 ~BadSpecifierDiagnoser() {
11533 return check(SpecLoc,
11539 if (!Specifiers.empty()) Specifiers +=
" ";
11540 Specifiers += Spec;
11545 std::string Specifiers;
11557 assert(GuidedTemplateDecl &&
"missing template decl for deduction guide");
11565 << GuidedTemplateDecl;
11571 if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
11572 DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
11573 DS.isNoreturnSpecified() || DS.hasConstexprSpecifier()) {
11574 BadSpecifierDiagnoser Diagnoser(
11576 diag::err_deduction_guide_invalid_specifier);
11578 Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
11579 DS.ClearStorageClassSpecs();
11583 Diagnoser.check(DS.getInlineSpecLoc(),
"inline");
11584 Diagnoser.check(DS.getNoreturnSpecLoc(),
"_Noreturn");
11585 Diagnoser.check(DS.getConstexprSpecLoc(),
"constexpr");
11586 DS.ClearConstexprSpec();
11588 Diagnoser.check(DS.getConstSpecLoc(),
"const");
11589 Diagnoser.check(DS.getRestrictSpecLoc(),
"__restrict");
11590 Diagnoser.check(DS.getVolatileSpecLoc(),
"volatile");
11591 Diagnoser.check(DS.getAtomicSpecLoc(),
"_Atomic");
11592 Diagnoser.check(DS.getUnalignedSpecLoc(),
"__unaligned");
11593 DS.ClearTypeQualifiers();
11595 Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
11596 Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
11597 Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
11598 Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
11599 DS.ClearTypeSpecType();
11606 bool FoundFunction =
false;
11612 diag::err_deduction_guide_with_complex_decl)
11616 if (!Chunk.Fun.hasTrailingReturnType())
11618 diag::err_deduction_guide_no_trailing_return_type);
11623 ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
11626 assert(TSI &&
"deduction guide has valid type but invalid return type?");
11627 bool AcceptableReturnType =
false;
11628 bool MightInstantiateToSpecialization =
false;
11631 TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
11632 bool TemplateMatches =
11634 auto TKind = SpecifiedName.
getKind();
11640 if (SimplyWritten && TemplateMatches)
11641 AcceptableReturnType =
true;
11646 MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
11650 MightInstantiateToSpecialization =
true;
11653 if (!AcceptableReturnType)
11655 diag::err_deduction_guide_bad_trailing_return_type)
11656 << GuidedTemplate << TSI->
getType()
11657 << MightInstantiateToSpecialization
11662 FoundFunction =
true;
11681 assert(*IsInline != PrevNS->
isInline());
11691 S.
Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
11694 S.
Diag(Loc, diag::err_inline_namespace_mismatch);
11712 bool IsInline = InlineLoc.
isValid();
11713 bool IsInvalid =
false;
11714 bool IsStd =
false;
11715 bool AddToKnown =
false;
11726 auto DiagnoseInlineStdNS = [&]() {
11727 assert(IsInline && II->
isStr(
"std") &&
11729 "Precondition of DiagnoseInlineStdNS not met");
11730 Diag(InlineLoc, diag::err_inline_namespace_std)
11750 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
11754 if (IsInline && II->
isStr(
"std") &&
11756 DiagnoseInlineStdNS();
11757 else if (IsInline != PrevNS->
isInline())
11759 &IsInline, PrevNS);
11760 }
else if (PrevDecl) {
11762 Diag(Loc, diag::err_redefinition_different_kind)
11767 }
else if (II->
isStr(
"std") &&
11770 DiagnoseInlineStdNS();
11775 AddToKnown = !IsInline;
11778 AddToKnown = !IsInline;
11792 if (PrevNS && IsInline != PrevNS->
isInline())
11794 &IsInline, PrevNS);
11807 if (
const VisibilityAttr *
Attr = Namespc->
getAttr<VisibilityAttr>())
11813 KnownNamespaces[Namespc] =
false;
11821 TU->setAnonymousNamespace(Namespc);
11823 cast<NamespaceDecl>(
Parent)->setAnonymousNamespace(Namespc);
11872 return AD->getNamespace();
11873 return dyn_cast_or_null<NamespaceDecl>(D);
11879 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
11880 assert(Namespc &&
"Invalid parameter, expected NamespaceDecl");
11883 if (Namespc->
hasAttr<VisibilityAttr>())
11886 if (DeferredExportedNamespaces.erase(Namespc))
11891 return cast_or_null<CXXRecordDecl>(
11900 return cast_or_null<NamespaceDecl>(
11905 enum UnsupportedSTLSelect {
11912 struct InvalidSTLDiagnoser {
11917 QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name =
"",
11918 const VarDecl *VD =
nullptr) {
11920 auto D = S.
Diag(Loc, diag::err_std_compare_type_not_supported)
11921 << TyForDiags << ((
int)Sel);
11922 if (Sel == USS_InvalidMember || Sel == USS_MissingMember) {
11923 assert(!Name.empty());
11927 if (Sel == USS_InvalidMember) {
11940 "Looking for comparison category type outside of C++.");
11954 if (Info && FullyCheckedComparisonCategories[
static_cast<unsigned>(
Kind)]) {
11965 std::string NameForDiags =
"std::";
11967 Diag(Loc, diag::err_implied_comparison_category_type_not_found)
11968 << NameForDiags << (
int)Usage;
11983 InvalidSTLDiagnoser UnsupportedSTLError{*
this, Loc, TyForDiags(Info)};
11986 return UnsupportedSTLError(USS_NonTrivial);
11991 if (
Base->isEmpty())
11994 return UnsupportedSTLError();
12003 !FIt->getType()->isIntegralOrEnumerationType()) {
12004 return UnsupportedSTLError();
12014 return UnsupportedSTLError(USS_MissingMember, MemName);
12017 assert(VD &&
"should not be null!");
12024 return UnsupportedSTLError(USS_InvalidMember, MemName, VD);
12030 return UnsupportedSTLError();
12037 FullyCheckedComparisonCategories[
static_cast<unsigned>(
Kind)] =
true;
12063 "Looking for std::initializer_list outside of C++.");
12077 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
12085 Template = dyn_cast_or_null<ClassTemplateDecl>(
12086 TST->getTemplateName().getAsTemplateDecl());
12087 Arguments = TST->template_arguments().begin();
12105 if (!isa<TemplateTypeParmDecl>(Params->
getParam(0)))
12117 *Element = Arguments[0].getAsType();
12124 S.
Diag(Loc, diag::err_implied_std_initializer_list_not_found);
12131 S.
Diag(Loc, diag::err_implied_std_initializer_list_not_found);
12136 Result.suppressDiagnostics();
12139 S.
Diag(Found->
getLocation(), diag::err_malformed_std_initializer_list);
12147 !isa<TemplateTypeParmDecl>(Params->
getParam(0))) {
12148 S.
Diag(Template->
getLocation(), diag::err_malformed_std_initializer_list);
12192 case Decl::TranslationUnit:
12194 case Decl::LinkageSpec:
12206 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
12208 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
12212 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12213 return std::make_unique<NamespaceValidatorCCC>(*
this);
12221 auto *ND = cast<NamespaceDecl>(Corrected.
getFoundDecl());
12222 Module *M = ND->getOwningModule();
12223 assert(M &&
"hidden namespace definition not in a module?");
12227 diag::err_module_unimported_use_header)
12232 diag::err_module_unimported_use)
12242 NamespaceValidatorCCC CCC{};
12252 if (isa_and_nonnull<NamespaceDecl>(Corrected.getFoundDecl()) &&
12253 Corrected.requiresImport()) {
12256 std::string CorrectedStr(Corrected.getAsString(S.
getLangOpts()));
12257 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
12258 Ident->
getName().equals(CorrectedStr);
12260 S.
PDiag(diag::err_using_directive_member_suggest)
12261 << Ident << DC << DroppedSpecifier << SS.
getRange(),
12262 S.
PDiag(diag::note_namespace_defined_here));
12265 S.
PDiag(diag::err_using_directive_suggest) << Ident,
12266 S.
PDiag(diag::note_namespace_defined_here));
12268 R.
addDecl(Corrected.getFoundDecl());
12279 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12280 assert(NamespcName &&
"Invalid NamespcName.");
12281 assert(IdentLoc.
isValid() &&
"Invalid NamespceName location.");
12284 S = S->getDeclParent();
12302 NamespcName->
isStr(
"std")) {
12303 Diag(IdentLoc, diag::ext_using_undefined_std);
12314 assert(NS &&
"expected namespace decl");
12333 CommonAncestor = CommonAncestor->
getParent();
12337 IdentLoc, Named, CommonAncestor);
12341 Diag(IdentLoc, diag::warn_using_directive_in_header);
12346 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
12379 Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);
12383 switch (Name.getKind()) {
12394 Diag(Name.getBeginLoc(),
12396 ? diag::warn_cxx98_compat_using_decl_constructor
12397 : diag::err_using_decl_constructor)
12405 Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.
getRange();
12409 Diag(Name.getBeginLoc(), diag::err_using_decl_template_id)
12410 <<
SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
12414 llvm_unreachable(
"cannot parse qualified deduction guide name");
12425 ? diag::err_access_decl
12426 : diag::warn_access_decl_deprecated)
12437 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
12445 SS, TargetNameInfo, EllipsisLoc, AttrList,
12459 assert(!SS->
isInvalid() &&
"ScopeSpec is invalid");
12469 ? diag::err_using_enum_is_dependent
12470 : diag::err_unknown_typename)
12476 auto *Enum = dyn_cast_if_present<EnumDecl>(EnumTy->
getAsTagDecl());
12478 Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;
12482 if (
auto *Def = Enum->getDefinition())
12485 if (TSI ==
nullptr)
12508 TD2->getUnderlyingType());
12512 if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
12513 isa<UnresolvedUsingIfExistsDecl>(D2))
12545 if (
auto *Using = dyn_cast<UsingDecl>(BUD)) {
12549 if (isa<EnumDecl>(OrigDC))
12557 Diag(Using->getLocation(),
12558 diag::err_using_decl_nested_name_specifier_is_current_class)
12559 << Using->getQualifierLoc().getSourceRange();
12561 Using->setInvalidDecl();
12565 Diag(Using->getQualifierLoc().getBeginLoc(),
12566 diag::err_using_decl_nested_name_specifier_is_not_base_class)
12567 << Using->getQualifier() << cast<CXXRecordDecl>(
CurContext)
12568 << Using->getQualifierLoc().getSourceRange();
12570 Using->setInvalidDecl();
12575 if (
Previous.empty())
return false;
12578 if (isa<UsingShadowDecl>(
Target))
12579 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12586 NamedDecl *NonTag =
nullptr, *Tag =
nullptr;
12587 bool FoundEquivalentDecl =
false;
12590 NamedDecl *D = (*I)->getUnderlyingDecl();
12594 if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D) || isa<UsingEnumDecl>(D))
12597 if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
12602 !isa<IndirectFieldDecl>(
Target) &&
12603 !isa<UnresolvedUsingValueDecl>(
Target) &&
12612 PrevShadow = Shadow;
12613 FoundEquivalentDecl =
true;
12617 FoundEquivalentDecl =
true;
12621 (isa<TagDecl>(D) ? Tag : NonTag) = D;
12624 if (FoundEquivalentDecl)
12629 if (isa<UnresolvedUsingIfExistsDecl>(
Target) !=
12630 (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
12631 if (!NonTag && !Tag)
12634 Diag(
Target->getLocation(), diag::note_using_decl_target);
12635 Diag((NonTag ? NonTag : Tag)->getLocation(),
12636 diag::note_using_decl_conflict);
12665 Diag(
Target->getLocation(), diag::note_using_decl_target);
12673 if (isa<TagDecl>(
Target)) {
12675 if (!Tag)
return false;
12678 Diag(
Target->getLocation(), diag::note_using_decl_target);
12679 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
12685 if (!NonTag)
return false;
12688 Diag(
Target->getLocation(), diag::note_using_decl_target);
12698 for (
auto &B : Derived->
bases())
12699 if (B.getType()->getAsCXXRecordDecl() ==
Base)
12700 return B.isVirtual();
12701 llvm_unreachable(
"not a direct base class");
12710 if (isa<UsingShadowDecl>(
Target)) {
12711 Target = cast<UsingShadowDecl>(
Target)->getTargetDecl();
12712 assert(!isa<UsingShadowDecl>(
Target) &&
"nested shadow declaration");
12716 if (
auto *TargetTD = dyn_cast<TemplateDecl>(
Target))
12717 NonTemplateTarget = TargetTD->getTemplatedDecl();
12720 if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
12721 UsingDecl *Using = cast<UsingDecl>(BUD);
12722 bool IsVirtualBase =
12724 Using->getQualifier()->getAsRecordDecl());
12778 cast<CXXRecordDecl>(Shadow->
getDeclContext())->removeConversion(Shadow);
12785 S->RemoveDecl(Shadow);
12799 bool &AnyDependentBases) {
12804 CanQualType BaseType =
Base.getType()->getCanonicalTypeUnqualified();
12805 if (CanonicalDesiredBase == BaseType)
12807 if (BaseType->isDependentType())
12808 AnyDependentBases =
true;
12816 UsingValidatorCCC(
bool HasTypenameKeyword,
bool IsInstantiation,
12818 : HasTypenameKeyword(HasTypenameKeyword),
12819 IsInstantiation(IsInstantiation), OldNNS(NNS),
12820 RequireMemberOf(RequireMemberOf) {}
12822 bool ValidateCandidate(
const TypoCorrection &Candidate)
override {
12826 if (!ND || isa<NamespaceDecl>(ND))
12836 if (RequireMemberOf) {
12837 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12838 if (FoundRecord && FoundRecord->isInjectedClassName()) {
12859 bool AnyDependentBases =
false;
12862 AnyDependentBases) &&
12863 !AnyDependentBases)
12867 if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
12873 auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
12874 if (FoundRecord && FoundRecord->isInjectedClassName())
12878 if (isa<TypeDecl>(ND))
12879 return HasTypenameKeyword || !IsInstantiation;
12881 return !HasTypenameKeyword;
12884 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
12885 return std::make_unique<UsingValidatorCCC>(*
this);
12889 bool HasTypenameKeyword;
12890 bool IsInstantiation;
12929 bool IsUsingIfExists) {
12930 assert(!SS.
isInvalid() &&
"Invalid CXXScopeSpec.");
12932 assert(IdentLoc.
isValid() &&
"Invalid TargetName location.");
12941 if (
auto *RD = dyn_cast<CXXRecordDecl>(
CurContext))
12954 assert(IsInstantiation &&
"no scope in non-instantiation");
12982 Diag(UsingLoc, diag::err_using_if_exists_on_ctor);
12988 if (!LookupContext || EllipsisLoc.
isValid()) {
12992 SS, NameInfo, IdentLoc))
12995 if (HasTypenameKeyword) {
12998 UsingLoc, TypenameLoc,
13000 IdentLoc, NameInfo.
getName(),
13004 QualifierLoc, NameInfo, EllipsisLoc);
13012 auto Build = [&](
bool Invalid) {
13015 UsingName, HasTypenameKeyword);
13022 auto BuildInvalid = [&]{
return Build(
true); };
13023 auto BuildValid = [&]{
return Build(
false); };
13026 return BuildInvalid();
13035 if (!IsInstantiation)
13052 if (R.
empty() && IsUsingIfExists)
13069 isa<TranslationUnitDecl>(LookupContext) &&
13072 UsingValidatorCCC CCC(HasTypenameKeyword, IsInstantiation, SS.
getScopeRep(),
13080 << NameInfo.
getName() << LookupContext << 0
13085 NamedDecl *ND = Corrected.getCorrectionDecl();
13087 return BuildInvalid();
13090 auto *RD = dyn_cast<CXXRecordDecl>(ND);
13093 RD = cast<CXXRecordDecl>(RD->
getParent());
13096 if (Corrected.WillReplaceSpecifier()) {
13098 Builder.MakeTrivial(
Context, Corrected.getCorrectionSpecifier(),
13100 QualifierLoc = Builder.getWithLocInContext(
Context);
13105 auto *CurClass = cast<CXXRecordDecl>(
CurContext);
13119 Diag(IdentLoc, diag::err_no_member)
13121 return BuildInvalid();
13126 return BuildInvalid();
13128 if (HasTypenameKeyword) {
13132 Diag(IdentLoc, diag::err_using_typename_non_type);
13134 Diag((*I)->getUnderlyingDecl()->getLocation(),
13135 diag::note_using_decl_target);
13136 return BuildInvalid();
13143 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
13145 return BuildInvalid();
13152 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
13154 return BuildInvalid();
13184 bool Invalid =
false;
13196 if (UED->getEnumDecl() == ED) {
13197 Diag(UsingLoc, diag::err_using_enum_decl_redeclaration)
13236 assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
13237 isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
13238 isa<UsingPackDecl>(InstantiatedFrom));
13242 UPD->setAccess(InstantiatedFrom->
getAccess());
13249 assert(!UD->
hasTypename() &&
"expecting a constructor name");
13252 assert(SourceType &&
13253 "Using decl naming constructor doesn't have type in scope spec.");
13257 bool AnyDependentBases =
false;
13259 AnyDependentBases);
13260 if (!
Base && !AnyDependentBases) {
13262 diag::err_using_decl_constructor_not_in_direct_base)
13264 <<
QualType(SourceType, 0) << TargetClass;
13270 Base->setInheritConstructors();
13279 bool HasTypenameKeyword,
13298 if (Qual->
isDependent() && !HasTypenameKeyword) {
13299 for (
auto *D : Prev) {
13300 if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
13301 bool OldCouldBeEnumerator =
13302 isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
13304 OldCouldBeEnumerator ? diag::err_redefinition
13305 : diag::err_redefinition_different_kind)
13306 << Prev.getLookupName();
13322 if (
UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
13323 DTypename = UD->hasTypename();
13324 DQual = UD->getQualifier();
13326 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
13328 DQual = UD->getQualifier();
13330 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
13332 DQual = UD->getQualifier();
13337 if (HasTypenameKeyword != DTypename)
continue;
13345 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.
getRange();
13366 assert(
bool(NamedContext) == (R || UD) && !(R && UD) &&
13367 "resolvable context must have exactly one set of decls");
13371 bool Cxx20Enumerator =
false;
13372 if (NamedContext) {
13381 if (
auto *ED = dyn_cast<EnumDecl>(NamedContext)) {
13385 if (EC && R && ED->isScoped())
13388 ? diag::warn_cxx17_compat_using_decl_scoped_enumerator
13389 : diag::ext_using_decl_scoped_enumerator)
13393 NamedContext = ED->getDeclContext();
13413 ? diag::warn_cxx17_compat_using_decl_class_member_enumerator
13414 : diag::err_using_decl_can_not_refer_to_class_member)
13417 if (Cxx20Enumerator)
13420 auto *RD = NamedContext
13432 Diag(SS.
getBeginLoc(), diag::note_using_decl_class_member_workaround)
13440 Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
13456 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13471 Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
13481 if (!NamedContext) {
13497 ? diag::warn_cxx17_compat_using_decl_non_member_enumerator
13498 : diag::err_using_decl_nested_name_specifier_is_not_class)
13501 if (Cxx20Enumerator)
13518 cast<CXXRecordDecl>(NamedContext))) {
13520 if (Cxx20Enumerator) {
13521 Diag(NameLoc, diag::warn_cxx17_compat_using_decl_non_member_enumerator)
13528 diag::err_using_decl_nested_name_specifier_is_current_class)
13533 if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
13535 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13560 Bases.insert(
Base);
13565 if (!cast<CXXRecordDecl>(
CurContext)->forallBases(Collect))
13571 return !Bases.count(
Base);
13576 if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
13577 !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
13581 diag::err_using_decl_nested_name_specifier_is_not_base_class)
13595 S = S->getDeclParent();
13597 if (
Type.isInvalid())
13600 bool Invalid =
false;
13616 TemplateParamLists.size()
13623 Previous.getFoundDecl()->isTemplateParameter()) {
13629 "name in alias declaration must be an identifier");
13631 Name.StartLocation,
13632 Name.Identifier, TInfo);
13646 bool Redeclaration =
false;
13649 if (TemplateParamLists.size()) {
13653 if (TemplateParamLists.size() != 1) {
13654 Diag(UsingLoc, diag::err_alias_template_extra_headers)
13655 <<
SourceRange(TemplateParamLists[1]->getTemplateLoc(),
13656 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13669 Redeclaration =
true;
13672 if (!OldDecl && !Invalid) {
13673 Diag(UsingLoc, diag::err_redefinition_different_kind)
13674 << Name.Identifier;
13688 OldTemplateParams =
13716 Name.Identifier, TemplateParams,
13724 else if (OldDecl) {
13731 if (
auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
13759 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.
getRange();
13791 Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
13793 Diag(AD->getLocation(), diag::note_previous_namespace_alias)
13794 << AD->getNamespace();
13799 ? diag::err_redefinition
13800 : diag::err_redefinition_different_kind;
13801 Diag(AliasLoc, DiagID) << Alias;
13822 struct SpecialMemberExceptionSpecInfo
13823 : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
13831 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
13836 void visitClassSubobject(
CXXRecordDecl *Class, Subobject Subobj,
13839 void visitSubobjectCall(Subobject Subobj,
13849 auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
13851 if (
auto *BaseCtor = SMOR.
getMethod()) {
13852 visitSubobjectCall(
Base, BaseCtor);
13856 visitClassSubobject(BaseClass,
Base, 0);
13860 bool SpecialMemberExceptionSpecInfo::visitField(
FieldDecl *FD) {
13872 ExceptSpec.CalledExpr(E);
13875 visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
13881 void SpecialMemberExceptionSpecInfo::visitClassSubobject(
CXXRecordDecl *Class,
13885 bool IsMutable =
Field &&
Field->isMutable();
13886 visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
13889 void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
13894 ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
13903 ExplicitSpec.
setKind(Result.getBoolValue()
13923 ComputingExceptionSpec CES(S, MD, Loc);
13930 SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, MD->
getLocation());
13932 return Info.ExceptSpec;
13939 diag::err_exception_spec_incomplete_type))
13940 return Info.ExceptSpec;
13957 Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
13958 : Info.VisitAllBases);
13960 return Info.ExceptSpec;
13965 struct DeclaringSpecialMember {
13969 bool WasAlreadyBeingDeclared;
13972 : S(S), D(RD, CSM), SavedContext(S, RD) {
13974 if (WasAlreadyBeingDeclared)
13995 ~DeclaringSpecialMember() {
13996 if (!WasAlreadyBeingDeclared) {
14003 bool isAlreadyBeingDeclared()
const {
14004 return WasAlreadyBeingDeclared;
14025 void Sema::setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
14043 cast<CXXRecordDecl>(SpecialMem->
getParent())->isLambda()) {
14059 "Should not build implicit default constructor!");
14061 DeclaringSpecialMember DSM(*
this, ClassDecl,
14063 if (DSM.isAlreadyBeingDeclared())
14086 setupImplicitSpecialMemberType(DefaultCon,
Context.
VoidTy, std::nullopt);
14110 ClassDecl->
addDecl(DefaultCon);
14117 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
14118 !Constructor->doesThisDeclarationHaveABody() &&
14119 !Constructor->isDeleted()) &&
14120 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
14121 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14125 assert(ClassDecl &&
"DefineImplicitDefaultConstructor - invalid constructor");
14139 Scope.addContextNote(CurrentLocation);
14142 Constructor->setInvalidDecl();
14147 ? Constructor->getEndLoc()
14148 : Constructor->getLocation();
14150 Constructor->markUsed(
Context);
14153 L->CompletedImplicitDefinition(Constructor);
14156 DiagnoseUninitializedFields(*
this, Constructor);
14182 ->getInheritedConstructor()
14185 return cast<CXXConstructorDecl>(Ctor);
14200 false, BaseCtor, &ICI);
14217 EPI.ExceptionSpec.SourceDecl = DerivedCtor;
14223 for (
unsigned I = 0, N = FPT->
getNumParams(); I != N; ++I) {
14227 Context, DerivedCtor, UsingLoc, UsingLoc,
nullptr,
14234 ParamDecls.push_back(PD);
14239 assert(!BaseCtor->
isDeleted() &&
"should not use deleted constructor");
14242 Derived->
addDecl(DerivedCtor);
14248 return DerivedCtor;
14262 assert(Constructor->getInheritedConstructor() &&
14263 !Constructor->doesThisDeclarationHaveABody() &&
14264 !Constructor->isDeleted());
14265 if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
14279 Scope.addContextNote(CurrentLocation);
14282 Constructor->getInheritedConstructor().getShadowDecl();
14284 Constructor->getInheritedConstructor().getConstructor();
14298 for (
bool VBase : {
false,
true}) {
14300 if (B.isVirtual() != VBase)
14303 auto *BaseRD = B.getType()->getAsCXXRecordDecl();
14308 if (!BaseCtor.first)
14313 InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);
14317 Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
14326 Constructor->setInvalidDecl();
14331 Constructor->markUsed(
Context);
14334 L->CompletedImplicitDefinition(Constructor);
14337 DiagnoseUninitializedFields(*
this, Constructor);
14347 DeclaringSpecialMember DSM(*
this, ClassDecl,
14349 if (DSM.isAlreadyBeingDeclared())
14370 Destructor->setDefaulted();
14372 setupImplicitSpecialMemberType(Destructor,
Context.
VoidTy, std::nullopt);
14383 Destructor->setTrivialForCall(ClassDecl->
hasAttr<TrivialABIAttr>() ||
14402 ClassDecl->
addDecl(Destructor);
14409 assert((Destructor->isDefaulted() &&
14410 !Destructor->doesThisDeclarationHaveABody() &&
14411 !Destructor->isDeleted()) &&
14412 "DefineImplicitDestructor - call it for implicit default dtor");
14413 if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
14417 assert(ClassDecl &&
"DefineImplicitDestructor - invalid destructor");
14428 Scope.addContextNote(CurrentLocation);
14431 Destructor->getParent());
14434 Destructor->setInvalidDecl();
14439 ? Destructor->getEndLoc()
14440 : Destructor->getLocation();
14442 Destructor->markUsed(
Context);
14445 L->CompletedImplicitDefinition(Destructor);
14451 if (Destructor->isInvalidDecl())
14456 "implicit complete dtors unneeded outside MS ABI");
14458 "complete dtor only exists for classes with vbases");
14463 Scope.addContextNote(CurrentLocation);
14473 if (
Record->isInvalidDecl()) {
14494 if (M->getParent()->getTemplateSpecializationKind() !=
14514 "adjusting dtor exception specs was introduced in c++11");
14516 if (Destructor->isDependentContext())
14524 if (DtorType->hasExceptionSpec())
14533 Destructor->setType(
14547 class ExprBuilder {
14548 ExprBuilder(
const ExprBuilder&) =
delete;
14549 ExprBuilder &operator=(
const ExprBuilder&) =
delete;
14552 static Expr *assertNotNull(
Expr *E) {
14553 assert(E &&
"Expression construction must not fail.");
14559 virtual ~ExprBuilder() {}
14564 class RefBuilder:
public ExprBuilder {
14574 : Var(Var), VarType(VarType) {}
14577 class ThisBuilder:
public ExprBuilder {
14584 class CastBuilder:
public ExprBuilder {
14585 const ExprBuilder &Builder;
14593 CK_UncheckedDerivedToBase,
Kind,
14602 class DerefBuilder:
public ExprBuilder {
14603 const ExprBuilder &Builder;
14607 return assertNotNull(
14611 DerefBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14614 class MemberBuilder:
public ExprBuilder {
14615 const ExprBuilder &Builder;
14625 nullptr, MemberLookup,
nullptr,
nullptr).get());
14628 MemberBuilder(
const ExprBuilder &Builder,
QualType Type,
bool IsArrow,
14630 : Builder(Builder),
Type(
Type), IsArrow(IsArrow),
14631 MemberLookup(MemberLookup) {}
14634 class MoveCastBuilder:
public ExprBuilder {
14635 const ExprBuilder &Builder;
14639 return assertNotNull(
CastForMoving(S, Builder.build(S, Loc)));
14642 MoveCastBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14645 class LvalueConvBuilder:
public ExprBuilder {
14646 const ExprBuilder &Builder;
14650 return assertNotNull(
14654 LvalueConvBuilder(
const ExprBuilder &Builder) : Builder(Builder) {}
14657 class SubscriptBuilder:
public ExprBuilder {
14658 const ExprBuilder &
Base;
14659 const ExprBuilder &Index;
14664 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).
get());
14667 SubscriptBuilder(
const ExprBuilder &
Base,
const ExprBuilder &Index)
14679 const ExprBuilder &ToB,
const ExprBuilder &FromB) {
14688 Expr *From = FromB.build(S, Loc);
14692 Expr *To = ToB.build(S, Loc);
14698 bool NeedsCollectableMemCpy =
14703 StringRef MemCpyName = NeedsCollectableMemCpy ?
14704 "__builtin_objc_memmove_collectable" :
14705 "__builtin_memcpy";
14718 assert(MemCpyRef.
isUsable() &&
"Builtin reference cannot fail");
14720 Expr *CallArgs[] = {
14724 Loc, CallArgs, Loc);
14726 assert(!Call.isInvalid() &&
"Call to __builtin_memcpy cannot fail!");
14727 return Call.getAs<
Stmt>();
14759 const ExprBuilder &To,
const ExprBuilder &From,
14760 bool CopyingBaseSubobject,
bool Copying,
14761 unsigned Depth = 0) {
14777 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
14812 if (CopyingBaseSubobject) {
14843 Expr *FromInst = From.build(S, Loc);
14846 Loc, FromInst, Loc);
14847 if (Call.isInvalid())
14866 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
14886 llvm::raw_svector_ostream OS(Str);
14887 OS <<
"__i" <<
Depth;
14891 IterationVarName, SizeType,
14900 RefBuilder IterationVarRef(IterationVar, SizeType);
14901 LvalueConvBuilder IterationVarRefRVal(IterationVarRef);
14907 SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
14908 MoveCastBuilder FromIndexMove(FromIndexCopy);
14909 const ExprBuilder *FromIndex;
14911 FromIndex = &FromIndexCopy;
14913 FromIndex = &FromIndexMove;
14915 SubscriptBuilder ToIndex(To, IterationVarRefRVal);
14920 ToIndex, *FromIndex, CopyingBaseSubobject,
14921 Copying,
Depth + 1);
14923 if (
Copy.isInvalid() || !
Copy.get())
14930 S.
Context, IterationVarRefRVal.build(S, Loc),
14944 Loc, Loc, InitStmt,
14951 const ExprBuilder &To,
const ExprBuilder &From,
14952 bool CopyingBaseSubobject,
bool Copying) {
14954 if (
T->
isArrayType() && !
T.isConstQualified() && !
T.isVolatileQualified() &&
14955 T.isTriviallyCopyableType(S.
Context))
14959 CopyingBaseSubobject,
14964 if (!Result.isInvalid() && !Result.get())
14977 DeclaringSpecialMember DSM(*
this, ClassDecl,
14979 if (DSM.isAlreadyBeingDeclared())
15014 setupImplicitSpecialMemberType(
CopyAssignment, RetType, ArgType);
15024 ClassLoc, ClassLoc,
15066 }
else if (!isa<CXXConstructorDecl>(CopyOp) &&
15069 for (
auto *I : RD->
ctors()) {
15070 if (I->isCopyConstructor()) {
15071 UserDeclaredOperation = I;
15075 assert(UserDeclaredOperation);
15076 }
else if (isa<CXXConstructorDecl>(CopyOp) &&
15079 for (
auto *I : RD->
methods()) {
15080 if (I->isCopyAssignmentOperator()) {
15081 UserDeclaredOperation = I;
15085 assert(UserDeclaredOperation);
15088 if (UserDeclaredOperation) {
15089 bool UDOIsUserProvided = UserDeclaredOperation->
isUserProvided();
15090 bool UDOIsDestructor = isa<CXXDestructorDecl>(UserDeclaredOperation);
15091 bool IsCopyAssignment = !isa<CXXConstructorDecl>(CopyOp);
15093 (UDOIsUserProvided && UDOIsDestructor)
15094 ? diag::warn_deprecated_copy_with_user_provided_dtor
15095 : (UDOIsUserProvided && !UDOIsDestructor)
15096 ? diag::warn_deprecated_copy_with_user_provided_copy
15097 : (!UDOIsUserProvided && UDOIsDestructor)
15098 ? diag::warn_deprecated_copy_with_dtor
15099 : diag::warn_deprecated_copy;
15101 << RD << IsCopyAssignment;
15112 "DefineImplicitCopyAssignment called for wrong function");
15130 Scope.addContextNote(CurrentLocation);
15165 RefBuilder OtherRef(
Other, OtherRefType);
15168 std::optional<ThisBuilder>
This;
15169 std::optional<DerefBuilder> DerefThis;
15170 std::optional<RefBuilder> ExplicitObject;
15171 bool IsArrow =
false;
15177 ExplicitObject.emplace(CopyAssignOperator->
getParamDecl(0), ObjectType);
15181 DerefThis.emplace(*
This);
15184 ExprBuilder &ObjectParameter =
15185 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15186 :
static_cast<ExprBuilder &
>(*This);
15189 bool Invalid =
false;
15190 for (
auto &
Base : ClassDecl->
bases()) {
15193 QualType BaseType =
Base.getType().getUnqualifiedType();
15200 BasePath.push_back(&
Base);
15209 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15210 :
static_cast<ExprBuilder &
>(*DerefThis),
15219 if (
Copy.isInvalid()) {
15225 Statements.push_back(
Copy.getAs<
Expr>());
15229 for (
auto *Field : ClassDecl->
fields()) {
15232 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15235 if (Field->isInvalidDecl()) {
15241 if (Field->getType()->isReferenceType()) {
15242 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15244 Diag(Field->getLocation(), diag::note_declared_at);
15252 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15254 Diag(Field->getLocation(), diag::note_declared_at);
15260 if (Field->isZeroLengthBitField(
Context))
15263 QualType FieldType = Field->getType().getNonReferenceType();
15266 "Incomplete array type is not valid");
15272 LookupResult MemberLookup(*
this, Field->getDeclName(), Loc,
15277 MemberBuilder From(OtherRef, OtherRefType,
false, MemberLookup);
15278 MemberBuilder To(ObjectParameter, ObjectType, IsArrow, MemberLookup);
15284 if (
Copy.isInvalid()) {
15290 Statements.push_back(
Copy.getAs<
Stmt>());
15296 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15297 :
LangOpts.HLSL ?
static_cast<ExprBuilder &
>(*This)
15298 :
static_cast<ExprBuilder &
>(*DerefThis))
15299 .build(*
this, Loc);
15304 Statements.push_back(Return.
getAs<
Stmt>());
15317 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15323 L->CompletedImplicitDefinition(CopyAssignOperator);
15330 DeclaringSpecialMember DSM(*
this, ClassDecl,
15332 if (DSM.isAlreadyBeingDeclared())
15366 setupImplicitSpecialMemberType(
MoveAssignment, RetType, ArgType);
15376 ClassLoc, ClassLoc,
15412 assert(!
Class->isDependentContext() &&
"should not define dependent move");
15418 if (
Class->getNumVBases() == 0 ||
Class->hasTrivialMoveAssignment() ||
15419 Class->getNumBases() < 2)
15423 typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15426 for (
auto &BI :
Class->bases()) {
15427 Worklist.push_back(&BI);
15428 while (!Worklist.empty()) {
15434 if (!
Base->hasNonTrivialMoveAssignment())
15459 VBases.insert(std::make_pair(
Base->getCanonicalDecl(), &BI))
15461 if (Existing && Existing != &BI) {
15462 S.
Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
15465 << (
Base->getCanonicalDecl() ==
15468 S.
Diag(BI.getBeginLoc(), diag::note_vbase_moved_here)
15469 << (
Base->getCanonicalDecl() ==
15470 BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
15474 Existing =
nullptr;
15484 llvm::append_range(Worklist, llvm::make_pointer_range(
Base->bases()));
15497 "DefineImplicitMoveAssignment called for wrong function");
15527 Scope.addContextNote(CurrentLocation);
15543 RefBuilder OtherRef(
Other, OtherRefType);
15545 MoveCastBuilder MoveOther(OtherRef);
15548 std::optional<ThisBuilder>
This;
15549 std::optional<DerefBuilder> DerefThis;
15550 std::optional<RefBuilder> ExplicitObject;
15556 ExplicitObject.emplace(MoveAssignOperator->
getParamDecl(0), ObjectType);
15560 DerefThis.emplace(*
This);
15562 ExprBuilder &ObjectParameter =
15563 ExplicitObject ? *ExplicitObject :
static_cast<ExprBuilder &
>(*This);
15566 bool Invalid =
false;
15567 for (
auto &
Base : ClassDecl->
bases()) {
15578 QualType BaseType =
Base.getType().getUnqualifiedType();
15585 BasePath.push_back(&
Base);
15589 CastBuilder From(OtherRef, BaseType,
VK_XValue, BasePath);
15594 ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15595 :
static_cast<ExprBuilder &
>(*DerefThis),
15604 if (
Move.isInvalid()) {
15610 Statements.push_back(
Move.getAs<
Expr>());
15614 for (
auto *Field : ClassDecl->
fields()) {
15617 if (Field->isUnnamedBitField() || Field->getParent()->isUnion())
15620 if (Field->isInvalidDecl()) {
15626 if (Field->getType()->isReferenceType()) {
15627 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15629 Diag(Field->getLocation(), diag::note_declared_at);
15637 Diag(ClassDecl->
getLocation(), diag::err_uninitialized_member_for_assign)
15639 Diag(Field->getLocation(), diag::note_declared_at);
15645 if (Field->isZeroLengthBitField(
Context))
15648 QualType FieldType = Field->getType().getNonReferenceType();
15651 "Incomplete array type is not valid");
15656 LookupResult MemberLookup(*
this, Field->getDeclName(), Loc,
15660 MemberBuilder From(MoveOther, OtherRefType,
15661 false, MemberLookup);
15662 MemberBuilder To(ObjectParameter, ObjectType, !ExplicitObject,
15665 assert(!From.build(*
this, Loc)->isLValue() &&
15666 "Member reference with rvalue base must be rvalue except for reference "
15667 "members, which aren't allowed for move assignment.");
15674 if (
Move.isInvalid()) {
15680 Statements.push_back(
Move.getAs<
Stmt>());
15686 (ExplicitObject ?
static_cast<ExprBuilder &
>(*ExplicitObject)
15687 :
static_cast<ExprBuilder &
>(*DerefThis))
15688 .build(*
this, Loc);
15694 Statements.push_back(Return.
getAs<
Stmt>());
15707 assert(!Body.
isInvalid() &&
"Compound statement creation cannot fail");
15713 L->CompletedImplicitDefinition(MoveAssignOperator);
15724 DeclaringSpecialMember DSM(*
this, ClassDecl,
15726 if (DSM.isAlreadyBeingDeclared())
15793 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15825 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
15830 assert(ClassDecl &&
"DefineImplicitCopyConstructor - invalid constructor");
15841 Scope.addContextNote(CurrentLocation);
15872 DeclaringSpecialMember DSM(*
this, ClassDecl,
15874 if (DSM.isAlreadyBeingDeclared())
15919 ClassLoc, ClassLoc,
15932 ClassDecl->
hasAttr<TrivialABIAttr>() ||
15964 "DefineImplicitMoveConstructor - call it for implicit move ctor");
15969 assert(ClassDecl &&
"DefineImplicitMoveConstructor - invalid constructor");
15980 Scope.addContextNote(CurrentLocation);
16027 if (CallOp != Invoker) {
16046 if (Invoker != CallOp) {
16059 assert(FunctionRef &&
"Can't refer to __invoke function?");
16067 L->CompletedImplicitDefinition(Conv);
16068 if (Invoker != CallOp)
16069 L->CompletedImplicitDefinition(Invoker);
16097 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16106 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
16112 Stmt *ReturnS = Return.
get();
16119 L->CompletedImplicitDefinition(Conv);
16126 switch (Args.size()) {
16131 if (!Args[1]->isDefaultArgument())
16136 return !Args[0]->isDefaultArgument();
16145 bool HadMultipleCandidates,
bool IsListInitialization,
16146 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16148 bool Elidable =
false;
16167 Expr *SubExpr = ExprArgs[0];
16177 FoundDecl, Constructor,
16178 Elidable, ExprArgs, HadMultipleCandidates,
16179 IsListInitialization,
16180 IsStdInitListInitialization, RequiresZeroInit,
16181 ConstructKind, ParenRange);
16187 bool HadMultipleCandidates,
bool IsListInitialization,
16188 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16190 if (
auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
16200 ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
16201 HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
16202 RequiresZeroInit, ConstructKind, ParenRange);
16210 bool HadMultipleCandidates,
bool IsListInitialization,
16211 bool IsStdInitListInitialization,
bool RequiresZeroInit,
16214 Constructor->getParent(),
16216 "given constructor for wrong type");
16223 Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
16224 HadMultipleCandidates, IsListInitialization,
16225 IsStdInitListInitialization, RequiresZeroInit,
16257 PDiag(diag::err_access_dtor_var)
16262 if (Destructor->isTrivial())
return;
16266 if (Destructor->isConstexpr()) {
16267 bool HasConstantInit =
false;
16274 diag::err_constexpr_var_requires_const_destruction) << VD;
16275 for (
unsigned I = 0, N = Notes.size(); I != N; ++I)
16276 Diag(Notes[I].first, Notes[I].second);
16285 if (!VD->
hasAttr<AlwaysDestroyAttr>())
16302 bool AllowExplicit,
16303 bool IsListInitialization) {
16305 unsigned NumArgs = ArgsPtr.size();
16306 Expr **Args = ArgsPtr.data();
16312 if (NumArgs < NumParams)
16313 ConvertedArgs.reserve(NumParams);
16315 ConvertedArgs.reserve(NumArgs);
16321 Loc, Constructor, Proto, 0,
llvm::ArrayRef(Args, NumArgs), AllArgs,
16322 CallType, AllowExplicit, IsListInitialization);
16323 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
16327 CheckConstructorCall(Constructor, DeclInitType,
16338 if (isa<NamespaceDecl>(DC)) {
16340 diag::err_operator_new_delete_declared_in_namespace)
16344 if (isa<TranslationUnitDecl>(DC) &&
16347 diag::err_operator_new_delete_declared_static)
16359 return Ctx.getPointerType(Ctx.getCanonicalType(Ctx.getQualifiedType(
16367 unsigned DependentParamTypeDiag,
16368 unsigned InvalidParamTypeDiag) {
16389 ? diag::err_operator_new_delete_dependent_result_type
16390 : diag::err_operator_new_delete_invalid_result_type)
16397 diag::err_operator_new_delete_template_too_few_parameters)
16403 diag::err_operator_new_delete_too_few_parameters)
16410 if (
const auto *PtrTy =
16415 ExpectedFirstParamType =
16421 ExpectedFirstParamType) {
16426 ? DependentParamTypeDiag
16427 : InvalidParamTypeDiag)
16428 << FnDecl->
getDeclName() << ExpectedFirstParamType;
16451 diag::err_operator_new_dependent_param_type,
16452 diag::err_operator_new_param_type))
16459 diag::err_operator_new_default_arg)
16474 auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);
16490 diag::err_operator_delete_dependent_param_type,
16491 diag::err_operator_delete_param_type))
16500 diag::err_destroying_operator_delete_not_usual);
16512 "Expected an overloaded operator declaration");
16522 if (Op == OO_Delete || Op == OO_Array_Delete)
16525 if (Op == OO_New || Op == OO_Array_New)
16535 if (
CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
16536 if (MethodDecl->isStatic()) {
16537 if (Op == OO_Call || Op == OO_Subscript)
16540 ? diag::warn_cxx20_compat_operator_overload_static
16541 : diag::ext_operator_overload_static))
16544 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_static)
16548 bool ClassOrEnumParam =
false;
16550 QualType ParamType = Param->getType().getNonReferenceType();
16553 ClassOrEnumParam =
true;
16558 if (!ClassOrEnumParam)
16560 diag::err_operator_overload_needs_class_or_enum)
16570 if (Op != OO_Call) {
16573 if (Param->hasDefaultArg()) {
16574 FirstDefaultedParam = Param;
16578 if (FirstDefaultedParam) {
16579 if (Op == OO_Subscript) {
16581 ? diag::ext_subscript_overload
16582 : diag::error_subscript_overload)
16587 diag::err_operator_overload_default_arg)
16595 {
false,
false,
false }
16596 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
16597 , { Unary, Binary, MemberOnly }
16598 #include "clang/Basic/OperatorKinds.def"
16601 bool CanBeUnaryOperator = OperatorUses[Op][0];
16602 bool CanBeBinaryOperator = OperatorUses[Op][1];
16603 bool MustBeMemberOperator = OperatorUses[Op][2];
16610 (isa<CXXMethodDecl>(FnDecl) &&
16614 if (Op != OO_Call && Op != OO_Subscript &&
16615 ((NumParams == 1 && !CanBeUnaryOperator) ||
16616 (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) ||
16617 (NumParams > 2))) {
16619 unsigned ErrorKind;
16620 if (CanBeUnaryOperator && CanBeBinaryOperator) {
16622 }
else if (CanBeUnaryOperator) {
16625 assert(CanBeBinaryOperator &&
16626 "All non-call overloaded operators are unary or binary!");
16629 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_must_be)
16630 << FnDecl->
getDeclName() << NumParams << ErrorKind;
16633 if (Op == OO_Subscript && NumParams != 2) {
16635 ? diag::ext_subscript_overload
16636 : diag::error_subscript_overload)
16637 << FnDecl->
getDeclName() << (NumParams == 1 ? 0 : 2);
16642 if (Op != OO_Call &&
16644 return Diag(FnDecl->
getLocation(), diag::err_operator_overload_variadic)
16649 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
16651 diag::err_operator_overload_must_be_member)
16665 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
16672 diag::err_operator_overload_post_incdec_must_be_int)
16673 << LastParam->
getType() << (Op == OO_MinusMinus);
16685 if (TemplateParams->
size() == 1) {
16687 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(0));
16706 }
else if (TemplateParams->
size() == 2) {
16708 dyn_cast<TemplateTypeParmDecl>(TemplateParams->
getParam(0));
16710 dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->
getParam(1));
16722 diag::ext_string_literal_operator_template);
16729 diag::err_literal_operator_template)
16738 if (isa<CXXMethodDecl>(FnDecl)) {
16739 Diag(FnDecl->
getLocation(), diag::err_literal_operator_outside_namespace)
16748 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
16767 diag::err_literal_operator_template_with_params);
16796 diag::err_literal_operator_param)
16813 diag::err_literal_operator_invalid_param)
16823 QualType FirstParamType = (*Param)->getType().getUnqualifiedType();
16830 Diag((*Param)->getSourceRange().getBegin(),
16831 diag::err_literal_operator_param)
16832 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16839 Diag((*Param)->getSourceRange().getBegin(),
16840 diag::err_literal_operator_param)
16841 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16854 Diag((*Param)->getSourceRange().getBegin(),
16855 diag::err_literal_operator_param)
16856 << FirstParamType <<
"'const char *'" << (*Param)->getSourceRange();
16864 QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
16866 Diag((*Param)->getSourceRange().getBegin(),
16867 diag::err_literal_operator_param)
16869 << (*Param)->getSourceRange();
16873 Diag(FnDecl->
getLocation(), diag::err_literal_operator_bad_param_count);
16882 if (Param->hasDefaultArg()) {
16883 Diag(Param->getDefaultArgRange().getBegin(),
16884 diag::err_literal_operator_default_argument)
16885 << Param->getDefaultArgRange();
16900 <<
static_cast<int>(Status)
16917 assert(Lit->
isUnevaluated() &&
"Unexpected string literal kind");
16923 else if (
Lang ==
"C++")
16926 Diag(LangStr->
getExprLoc(), diag::err_language_linkage_spec_unknown)
16946 if (
getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
16947 Module *GlobalModule = PushImplicitGlobalModuleFragment(ExternLoc);
16974 PopImplicitGlobalModuleFragment();
16977 return LinkageSpec;
16999 bool Invalid =
false;
17013 Diag(Loc, diag::err_catch_rvalue_ref);
17018 Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
17024 unsigned DK = diag::err_catch_incomplete;
17028 DK = diag::err_catch_incomplete_ptr;
17031 BaseType = Ref->getPointeeType();
17033 DK = diag::err_catch_incomplete_ref;
17035 if (!Invalid && (Mode == 0 || !BaseType->
isVoidType()) &&
17040 Diag(Loc, diag::err_wasm_reftype_tc) << 1;
17045 Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
17051 diag::err_abstract_type_in_decl,
17063 Diag(Loc, diag::err_objc_object_catch);
17068 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
17102 Expr *opaqueValue =
17150 assert(!S->isDeclScope(PrevDecl));
17154 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
17156 }
else if (PrevDecl->isTemplateParameter())
17184 Expr *AssertMessageExpr,
17190 AssertMessageExpr, RParenLoc,
false);
17195 case BuiltinType::Char_S:
17196 case BuiltinType::Char_U:
17198 case BuiltinType::Char8:
17201 case BuiltinType::Char16:
17204 case BuiltinType::Char32:
17207 case BuiltinType::WChar_S:
17208 case BuiltinType::WChar_U:
17212 llvm_unreachable(
"Non-character type");
17222 char Arr[UNI_MAX_UTF8_BYTES_PER_CODE_POINT];
17225 llvm::raw_svector_ostream OS(Str);
17229 if (K == BuiltinType::Char_S || K == BuiltinType::Char_U ||
17230 K == BuiltinType::Char8 ||
Value <= 0x7F) {
17231 StringRef Escaped = escapeCStyle<EscapeChar::Single>(
Value);
17232 if (!Escaped.empty())
17235 OS << static_cast<char>(
Value);
17240 case BuiltinType::Char16:
17241 case BuiltinType::Char32:
17242 case BuiltinType::WChar_S:
17243 case BuiltinType::WChar_U: {
17244 if (llvm::ConvertCodePointToUTF8(
Value, Ptr))
17248 << llvm::format_hex_no_prefix(
Value, TyWidth / 4,
true);
17252 llvm_unreachable(
"Non-character type is passed");
17264 switch (
V.getKind()) {
17265 case APValue::ValueKind::Int:
17270 int64_t BoolValue =
V.getInt().getExtValue();
17271 assert((BoolValue == 0 || BoolValue == 1) &&
17272 "Bool type, but value is not 0 or 1");
17273 llvm::raw_svector_ostream OS(Str);
17274 OS << (BoolValue ?
"true" :
"false");
17276 llvm::raw_svector_ostream OS(Str);
17281 switch (BTy->getKind()) {
17282 case BuiltinType::Char_S:
17283 case BuiltinType::Char_U:
17284 case BuiltinType::Char8:
17285 case BuiltinType::Char16:
17286 case BuiltinType::Char32:
17287 case BuiltinType::WChar_S:
17288 case BuiltinType::WChar_U: {
17290 assert(8 <= TyWidth && TyWidth <= 32 &&
"Unexpected integer width");
17291 uint32_t CodeUnit =
static_cast<uint32_t
>(
V.getInt().getZExtValue());
17296 << llvm::format_hex_no_prefix(CodeUnit, 2,
17298 <<
", " <<
V.getInt() <<
')';
17305 V.getInt().toString(Str);
17311 V.getFloat().toString(Str);
17314 case APValue::ValueKind::LValue:
17315 if (
V.isNullPointer()) {
17316 llvm::raw_svector_ostream OS(Str);
17322 case APValue::ValueKind::ComplexFloat: {
17323 llvm::raw_svector_ostream OS(Str);
17325 V.getComplexFloatReal().toString(Str);
17327 V.getComplexFloatImag().toString(Str);
17331 case APValue::ValueKind::ComplexInt: {
17332 llvm::raw_svector_ostream OS(Str);
17334 V.getComplexIntReal().toString(Str);
17336 V.getComplexIntImag().toString(Str);
17359 if (isa<SubstNonTypeTemplateParmExpr>(E))
17363 if (
const auto *UnaryOp = dyn_cast<UnaryOperator>(E))
17367 if (
const auto *BO = dyn_cast<BinaryOperator>(E))
17368 return (BO->isShiftOp() || BO->isAdditiveOp() || BO->isMultiplicativeOp() ||
17369 BO->isBitwiseOp());
17377 if (
const auto *Op = dyn_cast<BinaryOperator>(E);
17378 Op && Op->getOpcode() != BO_LOr) {
17379 const Expr *LHS = Op->getLHS()->IgnoreParenImpCasts();
17380 const Expr *RHS = Op->getRHS()->IgnoreParenImpCasts();
17398 for (
unsigned I = 0; I < 2; I++) {
17399 const Expr *Side = DiagSide[I].Cond;
17403 DiagSide[I].Print =
17405 DiagSide[I].ValueString,
Context);
17407 if (DiagSide[0].Print && DiagSide[1].Print) {
17408 Diag(Op->getExprLoc(), diag::note_expr_evaluates_to)
17409 << DiagSide[0].ValueString << Op->getOpcodeStr()
17410 << DiagSide[1].ValueString << Op->getSourceRange();
17416 std::string &Result,
17418 bool ErrorOnInvalidMessage) {
17420 assert(!Message->isTypeDependent() && !Message->isValueDependent() &&
17421 "can't evaluate a dependant static assert message");
17423 if (
const auto *SL = dyn_cast<StringLiteral>(Message)) {
17424 assert(SL->isUnevaluated() &&
"expected an unevaluated string");
17425 Result.assign(SL->getString().begin(), SL->getString().end());
17430 QualType T = Message->getType().getNonReferenceType();
17433 Diag(Loc, diag::err_static_assert_invalid_message);
17437 auto FindMember = [&](StringRef
Member,
bool &Empty,
17438 bool Diag =
false) -> std::optional<LookupResult> {
17442 Empty = MemberLookup.
empty();
17445 if (MemberLookup.
empty())
17446 return std::nullopt;
17447 return std::move(MemberLookup);
17450 bool SizeNotFound, DataNotFound;
17451 std::optional<LookupResult> SizeMember = FindMember(
"size", SizeNotFound);
17452 std::optional<LookupResult> DataMember = FindMember(
"data", DataNotFound);
17453 if (SizeNotFound || DataNotFound) {
17454 Diag(Loc, diag::err_static_assert_missing_member_function)
17455 << ((SizeNotFound && DataNotFound) ? 2
17461 if (!SizeMember || !DataMember) {
17463 FindMember(
"size", SizeNotFound,
true);
17465 FindMember(
"data", DataNotFound,
true);
17471 Message, Message->getType(), Message->getBeginLoc(),
false,
17496 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 0;
17506 Diag(Loc, diag::err_static_assert_invalid_mem_fn_ret_ty) << 1;
17510 if (!ErrorOnInvalidMessage &&
17511 Diags.
isIgnored(diag::warn_static_assert_message_constexpr, Loc))
17516 Status.Diag = &Notes;
17517 if (!Message->EvaluateCharRangeAsString(Result, EvaluatedSize.
get(),
17518 EvaluatedData.
get(), Ctx, Status) ||
17520 Diag(Message->getBeginLoc(),
17521 ErrorOnInvalidMessage ? diag::err_static_assert_message_constexpr
17522 : diag::warn_static_assert_message_constexpr);
17523 for (
const auto &Note : Notes)
17524 Diag(Note.first, Note.second);
17525 return !ErrorOnInvalidMessage;
17531 Expr *AssertExpr,
Expr *AssertMessage,
17534 assert(AssertExpr !=
nullptr &&
"Expected non-null condition");
17552 AssertExpr = FullAssertExpr.
get();
17555 Expr *BaseExpr = AssertExpr;
17567 diag::err_static_assert_expression_is_not_constant,
17573 if (!Failed && AssertMessage && Cond.getBoolValue()) {
17582 bool InTemplateDefinition =
17585 if (!Failed && !Cond && !InTemplateDefinition) {
17587 llvm::raw_svector_ostream Msg(MsgBuffer);
17588 bool HasMessage = AssertMessage;
17589 if (AssertMessage) {
17593 AssertMessage, Str,
Context,
true) ||
17597 Expr *InnerCond =
nullptr;
17598 std::string InnerCondDescription;
17599 std::tie(InnerCond, InnerCondDescription) =
17601 if (InnerCond && isa<ConceptSpecializationExpr>(InnerCond)) {
17609 }
else if (InnerCond && !isa<CXXBoolLiteralExpr>(InnerCond)
17610 && !isa<IntegerLiteral>(InnerCond)) {
17612 diag::err_static_assert_requirement_failed)
17613 << InnerCondDescription << !HasMessage << Msg.str()
17630 AssertExpr = FullAssertExpr.
get();
17634 AssertExpr, AssertMessage, RParenLoc,
17649 bool IsMemberSpecialization =
false;
17650 bool Invalid =
false;
17654 TagLoc, NameLoc, SS,
nullptr, TempParamLists,
true,
17655 IsMemberSpecialization, Invalid)) {
17656 if (TemplateParams->size() > 0) {
17664 FriendLoc, TempParamLists.size() - 1,
17665 TempParamLists.data()).
get();
17668 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
17670 IsMemberSpecialization =
true;
17674 if (Invalid)
return true;
17676 bool isAllExplicitSpecializations =
true;
17677 for (
unsigned I = TempParamLists.size(); I-- > 0; ) {
17678 if (TempParamLists[I]->size()) {
17679 isAllExplicitSpecializations =
false;
17689 if (isAllExplicitSpecializations) {
17691 bool Owned =
false;
17692 bool IsDependent =
false;
17713 if (isa<DependentNameType>(
T)) {
17727 TSI, FriendLoc, TempParamLists);
17733 assert(SS.
isNotEmpty() &&
"valid templated tag with no SS and no direct?");
17740 Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
17751 TSI, FriendLoc, TempParamLists);
17793 Diag(FriendLoc, diag::err_friend_not_first_in_declaration);
17821 if (TempParams.size()) {
17838 ? diag::warn_cxx98_compat_unelaborated_friend_type
17839 : diag::ext_unelaborated_friend_type)
17845 ? diag::warn_cxx98_compat_nonclass_type_friend
17846 : diag::ext_nonclass_type_friend)
17863 if (!TempParams.empty())
17900 Diag(Loc, diag::err_unexpected_friend);
17935 Scope *DCScope = S;
17947 (FunctionContainingLocalClass =
17948 cast<CXXRecordDecl>(
CurContext)->isLocalClass())) {
17960 DCScope = S->getFnParent();
17970 DC =
Previous.getRepresentativeDecl()->getDeclContext();
17974 DC = FunctionContainingLocalClass;
18011 if (isTemplateId) {
18012 if (isa<TranslationUnitDecl>(LookupDC))
break;
18026 if (!DC)
return nullptr;
18037 diag::warn_cxx98_compat_friend_is_member :
18038 diag::err_friend_is_member);
18047 assert(isa<CXXRecordDecl>(DC) &&
"friend declaration not in class?");
18074 if (DiagArg >= 0) {
18075 Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
18086 DCScope = &FakeDCScope;
18089 bool AddToScope =
true;
18091 TemplateParams, AddToScope);
18092 if (!ND)
return nullptr;
18126 FD = FTD->getTemplatedDecl();
18128 FD = cast<FunctionDecl>(ND);
18148 }
else if (FunctionContainingLocalClass) {
18157 }
else if (isTemplateId) {
18171 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
18173 diag::note_previous_declaration);
18175 Diag(FD->
getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
18180 Diag(FD->
getLocation(), diag::warn_template_qualified_friend_unsupported)
18196 FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
18198 Diag(DelLoc, diag::err_deleted_non_function);
18209 Prev->getPreviousDecl()) &&
18210 !Prev->isDefined()) {
18211 Diag(DelLoc, diag::err_deleted_decl_not_first);
18212 Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
18213 Prev->isImplicit() ? diag::note_previous_implicit_declaration
18214 : diag::note_previous_declaration);
18237 Diag(DelLoc, diag::err_deleted_main);
18249 auto *FD = dyn_cast<FunctionDecl>(Dcl);
18251 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(Dcl)) {
18253 Diag(DefaultLoc, diag::err_defaulted_comparison_template);
18258 Diag(DefaultLoc, diag::err_default_special_members)
18269 (!FD->isDependentContext() ||
18270 (!isa<CXXConstructorDecl>(FD) &&
18272 Diag(DefaultLoc, diag::err_default_special_members)
18282 ? diag::warn_cxx17_compat_defaulted_comparison
18283 : diag::ext_defaulted_comparison);
18286 FD->setDefaulted();
18287 FD->setExplicitlyDefaulted();
18288 FD->setDefaultLoc(DefaultLoc);
18291 if (FD->isDependentContext())
18297 FD->setWillHaveBody(
false);
18310 if (isa<CXXMethodDecl>(FD)) {
18312 if (
const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
18326 auto *MD = cast<CXXMethodDecl>(FD);
18337 for (
Stmt *SubStmt : S->children()) {
18340 if (isa<ReturnStmt>(SubStmt))
18341 Self.Diag(SubStmt->getBeginLoc(),
18342 diag::err_return_in_constructor_handler);
18343 if (!isa<Expr>(SubStmt))
18349 for (
unsigned I = 0, E = TryBlock->
getNumHandlers(); I != E; ++I) {
18357 switch (BodyKind) {
18366 "Parsed function body should be '= delete;' or '= default;'");
18376 for (
unsigned I = 0, E = OldFT->
getNumParams(); I != E; ++I)
18380 !NewFT->getExtParameterInfo(I).isNoEscape()) {
18382 diag::warn_overriding_method_missing_noescape);
18384 diag::note_overridden_marked_noescape);
18390 Diag(New->
getLocation(), diag::err_conflicting_overriding_attributes)
18397 const auto *OldCSA = Old->
getAttr<CodeSegAttr>();
18398 const auto *NewCSA = New->
getAttr<CodeSegAttr>();
18399 if ((NewCSA || OldCSA) &&
18400 (!OldCSA || !NewCSA || NewCSA->getName() != OldCSA->getName())) {
18409 if (NewCC == OldCC)
18420 diag::err_conflicting_overriding_cc_attributes)
18433 diag::err_explicit_object_parameter_nonmember)
18460 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
18468 if (NewClassTy.
isNull()) {
18470 diag::err_different_return_type_for_overriding_virtual_function)
18486 if (!RT->isBeingDefined() &&
18488 diag::err_covariant_return_incomplete,
18505 NewClassTy, OldClassTy,
18506 diag::err_covariant_return_inaccessible_base,
18507 diag::err_covariant_return_ambiguous_derived_to_base_conv,
18523 diag::err_covariant_return_type_different_qualifications)
18535 diag::err_covariant_return_type_class_type_more_qualified)
18570 else if (
auto *M = dyn_cast<CXXMethodDecl>(D))
18579 if (
const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
18580 return Var->hasGlobalStorage();
18634 "Parser allowed 'typedef' as storage class of condition decl.");
18640 if (isa<FunctionDecl>(Dcl)) {
18646 if (
auto *VD = dyn_cast<VarDecl>(Dcl))
18659 for (
unsigned I = 0, N = VTables.size(); I != N; ++I) {
18660 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
18664 if (!Pos->second && VTables[I].DefinitionRequired)
18665 Pos->second =
true;
18669 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
18670 NewUses.push_back(
VTableUse(VTables[I].
Record, VTables[I].Location));
18677 bool DefinitionRequired) {
18680 if (!
Class->isDynamicClass() ||
Class->isDependentContext() ||
18686 !
OpenMP().isInOpenMPDeclareTargetContext() &&
18687 !
OpenMP().isInOpenMPTargetExecutionDirective()) {
18688 if (!DefinitionRequired)
18696 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator,
bool>
18702 if (DefinitionRequired && !Pos.first->second) {
18703 Pos.first->second =
true;
18732 if (
Class->isLocalClass())
18747 bool DefinedAnything =
false;
18748 for (
unsigned I = 0; I !=
VTableUses.size(); ++I) {
18753 Class->getTemplateSpecializationKind();
18757 bool DefineVTable =
true;
18763 if (KeyFunction && !KeyFunction->
hasBody()) {
18765 DefineVTable =
false;
18770 "Instantiations don't have key functions");
18772 }
else if (!KeyFunction) {
18777 bool IsExplicitInstantiationDeclaration =
18779 for (
auto *R :
Class->redecls()) {
18781 = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
18783 IsExplicitInstantiationDeclaration =
true;
18785 IsExplicitInstantiationDeclaration =
false;
18790 if (IsExplicitInstantiationDeclaration)
18791 DefineVTable =
false;
18797 if (!DefineVTable) {
18805 DefinedAnything =
true;
18818 if (!KeyFunction || (KeyFunction->
hasBody(KeyFunctionDef) &&
18825 return DefinedAnything;
18830 for (
const auto *I : RD->
methods())
18831 if (I->isVirtual() && !I->isPureVirtual())
18837 bool ConstexprOnly) {
18841 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
18842 E = FinalOverriders.end();
18845 OE = I->second.end();
18847 assert(OI->second.size() > 0 &&
"no final overrider");
18862 for (
const auto &I : RD->
bases()) {
18865 if (
Base->getNumVBases() == 0)
18882 for (
unsigned i = 0; i < ivars.size(); i++) {
18884 if (Field->isInvalidDecl())
18894 InitSeq.
Perform(*
this, InitEntity, InitKind, std::nullopt);
18906 AllToInit.push_back(
Member);
18911 ->getAs<RecordType>()) {
18912 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
18916 PDiag(diag::err_access_dtor_ivar)
18922 AllToInit.data(), AllToInit.size());
18943 cast_or_null<CXXConstructorDecl>(FNTarget));
18950 if (!Current.insert(Canonical).second)
18955 Target->isInvalidDecl() || Valid.count(TCanonical)) {
18956 Valid.insert(Current.begin(), Current.end());
18959 }
else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
18960 Current.count(TCanonical)) {
18962 if (!Invalid.count(TCanonical)) {
18964 diag::warn_delegating_ctor_cycle)
18968 if (TCanonical != Canonical)
18969 S.
Diag(
Target->getLocation(), diag::note_it_delegates_to);
18972 while (C->getCanonicalDecl() != Canonical) {
18974 (void)C->getTargetConstructor()->hasBody(FNTarget);
18975 assert(FNTarget &&
"Ctor cycle through bodiless function");
18978 cast<CXXConstructorDecl>(FNTarget));
18979 S.
Diag(C->getLocation(), diag::note_which_delegates_to);
18983 Invalid.insert(Current.begin(), Current.end());
18994 for (DelegatingCtorDeclsType::iterator
19000 for (
auto CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
19001 (*CI)->setInvalidDecl();
19010 explicit FindCXXThisExpr(
Sema &S) : S(S) { }
19038 FindCXXThisExpr Finder(*
this);
19051 if (!Finder.TraverseStmt(E))
19068 FindCXXThisExpr Finder(*
this);
19090 if (!Finder.TraverseType(E))
19100 FindCXXThisExpr Finder(*
this);
19103 for (
const auto *A : Method->
attrs()) {
19105 Expr *Arg =
nullptr;
19107 if (
const auto *G = dyn_cast<GuardedByAttr>(A))
19109 else if (
const auto *G = dyn_cast<PtGuardedByAttr>(A))
19111 else if (
const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
19113 else if (
const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
19115 else if (
const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
19116 Arg = ETLF->getSuccessValue();
19118 }
else if (
const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
19119 Arg = STLF->getSuccessValue();
19121 }
else if (
const auto *LR = dyn_cast<LockReturnedAttr>(A))
19122 Arg = LR->getArg();
19123 else if (
const auto *
LE = dyn_cast<LocksExcludedAttr>(A))
19125 else if (
const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
19127 else if (
const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
19129 else if (
const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
19131 else if (
const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
19134 if (Arg && !Finder.TraverseStmt(Arg))
19137 for (
unsigned I = 0, N = Args.size(); I != N; ++I) {
19138 if (!Finder.TraverseStmt(Args[I]))
19152 Exceptions.clear();
19155 Exceptions.reserve(DynamicExceptions.size());
19156 for (
unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
19163 if (!Unexpanded.empty()) {
19174 Exceptions.push_back(ET);
19184 "Parser should have made sure that the expression is boolean");
19200 Expr *NoexceptExpr) {
19206 MethodD = FunTmpl->getTemplatedDecl();
19216 DynamicExceptionRanges, NoexceptExpr, Exceptions,
19242 Diag(DeclStart, diag::err_anonymous_property);
19267 diag::err_invalid_thread)
19275 switch (
Previous.getResultKind()) {
19282 PrevDecl =
Previous.getRepresentativeDecl();
19295 PrevDecl =
nullptr;
19299 PrevDecl =
nullptr;
19310 Record->setInvalidDecl();
19332 if (!ExplicitLists.empty()) {
19333 bool IsMemberSpecialization, IsInvalid;
19337 ExplicitLists,
false, IsMemberSpecialization, IsInvalid,
19349 if (ExplicitParams && !ExplicitParams->
empty()) {
19350 Info.AutoTemplateParameterDepth = ExplicitParams->
getDepth();
19351 llvm::append_range(Info.TemplateParams, *ExplicitParams);
19352 Info.NumExplicitTemplateParams = ExplicitParams->
size();
19354 Info.AutoTemplateParameterDepth = TemplateParameterDepth;
19355 Info.NumExplicitTemplateParams = 0;
19361 if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
19362 if (FSI.NumExplicitTemplateParams != 0) {
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Target Target
llvm::MachO::Record Record
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
@ ForExternalRedeclaration
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
@ ForVisibleRedeclaration
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings
This file declares semantic analysis for CUDA constructs.
static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation)
Check if we're implicitly defining a move assignment operator for a class with virtual bases.
static void checkMethodTypeQualifiers(Sema &S, Declarator &D, unsigned DiagID)
static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Valid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Invalid, llvm::SmallPtrSet< CXXConstructorDecl *, 4 > &Current, Sema &S)
static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind)
Check the body for the given constexpr function declaration only contains the permitted types of stat...
llvm::SmallPtrSet< QualType, 4 > IndirectBaseSet
Use small set to collect indirect bases.
static void checkCUDADeviceBuiltinSurfaceClassTemplate(Sema &S, CXXRecordDecl *Class)
static bool checkVectorDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const VectorType *VT)
static bool CheckLiteralType(Sema &SemaRef, Sema::CheckConstexprKind Kind, SourceLocation Loc, QualType T, unsigned DiagID, Ts &&...DiagArgs)
Check that the given type is a literal type.
static void SearchForReturnInStmt(Sema &Self, Stmt *S)
static void extendRight(SourceRange &R, SourceRange After)
static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, IdentifierInfo *II, bool *IsInline, NamespaceDecl *PrevNS)
Diagnose a mismatch in 'inline' qualifiers when a namespace is reopened.
static bool RefersToRValueRef(Expr *MemRef)
static ClassTemplateDecl * LookupStdInitializerList(Sema &S, SourceLocation Loc)
static CanQualType RemoveAddressSpaceFromPtr(Sema &SemaRef, const PointerType *PtrTy)
static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base)
Determine whether a direct base class is a virtual base class.
static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T, llvm::APSInt &Size)
#define CheckPolymorphic(Type)
static bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current)
Determine whether the given class is a base class of the given class, including looking at dependent ...
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
static void WriteCharValueForDiagnostic(uint32_t Value, const BuiltinType *BTy, unsigned TyWidth, SmallVectorImpl< char > &Str)
Convert character's value, interpreted as a code unit, to a string.
static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc, QualType SubType, bool ConstRHS, CXXSpecialMemberKind CSM, TrivialSubobjectKind Kind, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the special member selected for a given type would be trivial.
static void CheckAbstractClassUsage(AbstractUsageInfo &Info, FunctionDecl *FD)
Check for invalid uses of an abstract type in a function declaration.
static unsigned getRecordDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for record diagnostic message.
static const void * GetKeyForBase(ASTContext &Context, QualType BaseType)
static void extendLeft(SourceRange &R, SourceRange Before)
static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, bool ConstArg, Sema::TrivialABIHandling TAH, bool Diagnose)
Check whether the members of a class type allow a special member to be trivial.
static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Is the special member function which would be selected to perform the specified operation on the spec...
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class....
static void lookupOperatorsForDefaultedComparison(Sema &Self, Scope *S, UnresolvedSetImpl &Operators, OverloadedOperatorKind Op)
Perform the unqualified lookups that might be needed to form a defaulted comparison function for the ...
static void WriteCharTypePrefix(BuiltinType::Kind BTK, llvm::raw_ostream &OS)
static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD, CXXSpecialMemberKind CSM, unsigned Quals, bool ConstRHS, Sema::TrivialABIHandling TAH, CXXMethodDecl **Selected)
Perform lookup for a special member of the specified kind, and determine whether it is trivial.
static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp)
Diagnose an implicit copy operation for a class which is odr-used, but which is deprecated because th...
static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl< const CXXMethodDecl * > &Methods)
Add the most overridden methods from MD to Methods.
static bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag)
static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, const CXXRecordDecl *RD, CXXCastPath &BasePath)
Find the base class to decompose in a built-in decomposition of a class type.
static Sema::ImplicitExceptionSpecification ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD, Sema::DefaultedComparisonKind DCK)
static StmtResult buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying, unsigned Depth=0)
Builds a statement that copies/moves the given entity from From to To.
static void checkCUDADeviceBuiltinTextureClassTemplate(Sema &S, CXXRecordDecl *Class)
static void AddInitializerToDiag(const Sema::SemaDiagnosticBuilder &Diag, const CXXCtorInitializer *Previous, const CXXCtorInitializer *Current)
static bool BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, CXXBaseSpecifier *BaseSpec, bool IsInheritedVirtualBase, CXXCtorInitializer *&CXXBaseInit)
static bool checkTupleLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, VarDecl *Src, QualType DecompType, const llvm::APSInt &TupleSize)
static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type)
Recursively add the bases of Type. Don't add Type itself.
static bool CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S, SmallVectorImpl< SourceLocation > &ReturnStmts, SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc, SourceLocation &Cxx2bLoc, Sema::CheckConstexprKind Kind)
Check the provided statement is allowed in a constexpr function definition.
static bool functionDeclHasDefaultArgument(const FunctionDecl *FD)
static bool CheckConstexprParameterTypes(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's parameter types are all literal types.
static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext)
Determine whether a using statement is in a context where it will be apply in all contexts.
static bool checkMemberDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const CXXRecordDecl *OrigRD)
static CXXConstructorDecl * findUserDeclaredCtor(CXXRecordDecl *RD)
static Expr * CastForMoving(Sema &SemaRef, Expr *E)
static void checkForMultipleExportedDefaultConstructors(Sema &S, CXXRecordDecl *Class)
static bool isNonlocalVariable(const Decl *D)
Determine whether the given declaration is a global variable or static data member.
static bool checkSimpleDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType, llvm::function_ref< ExprResult(SourceLocation, Expr *, unsigned)> GetInit)
static TemplateArgumentLoc getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T)
static void findImplicitlyDeclaredEqualityComparisons(ASTContext &Ctx, CXXRecordDecl *RD, llvm::SmallVectorImpl< FunctionDecl * > &Spaceships)
Find the equality comparison functions that should be implicitly declared in a given class definition...
static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl< const void * > &IdealInits)
ImplicitInitializerKind
ImplicitInitializerKind - How an implicit base or member initializer should initialize its base or me...
static bool ConvertAPValueToString(const APValue &V, QualType T, SmallVectorImpl< char > &Str, ASTContext &Context)
Convert \V to a string we can present to the user in a diagnostic \T is the type of the expression th...
static bool checkArrayDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ConstantArrayType *CAT)
static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class)
static bool UsefulToPrintExpr(const Expr *E)
Some Expression types are not useful to print notes about, e.g.
static bool FindBaseInitializer(Sema &SemaRef, CXXRecordDecl *ClassDecl, QualType BaseType, const CXXBaseSpecifier *&DirectBaseSpec, const CXXBaseSpecifier *&VirtualBaseSpec)
Find the direct and/or virtual base specifiers that correspond to the given base type,...
static bool checkLiteralOperatorTemplateParameterList(Sema &SemaRef, FunctionTemplateDecl *TpDecl)
static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool ReportOverrides(Sema &S, unsigned DiagID, const CXXMethodDecl *MD, llvm::function_ref< bool(const CXXMethodDecl *)> Report)
Report an error regarding overriding, along with any relevant overridden methods.
static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl)
static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy, TemplateArgumentListInfo &Args, const TemplateParameterList *Params)
static bool CheckConstexprReturnType(Sema &SemaRef, const FunctionDecl *FD, Sema::CheckConstexprKind Kind)
Check whether a function's return type is a literal type.
static void DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef, const CXXConstructorDecl *Constructor, ArrayRef< CXXCtorInitializer * > Inits)
static Sema::ImplicitExceptionSpecification computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD)
static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T)
Determine whether the given type is an incomplete or zero-lenfgth array type.
static CXXBaseSpecifier * findDirectBaseWithType(CXXRecordDecl *Derived, QualType DesiredBase, bool &AnyDependentBases)
Find the base specifier for a base class with the given type.
TrivialSubobjectKind
The kind of subobject we are checking for triviality.
@ TSK_CompleteObject
The object is actually the complete object.
@ TSK_Field
The subobject is a non-static data member.
@ TSK_BaseClass
The subobject is a base class.
static bool hasOneRealArgument(MultiExprArg Args)
Determine whether the given list arguments contains exactly one "real" (non-default) argument.
static StmtResult buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &ToB, const ExprBuilder &FromB)
When generating a defaulted copy or move assignment operator, if a field should be copied with __buil...
static void DefineDefaultedFunction(Sema &S, FunctionDecl *FD, SourceLocation DefaultLoc)
static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit)
static NamespaceDecl * getNamespaceDecl(NamedDecl *D)
getNamespaceDecl - Returns the namespace a decl represents.
static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info, FieldDecl *Field, IndirectFieldDecl *Indirect=nullptr)
static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(Sema &S, CXXRecordDecl *Class, CXXSpecialMemberKind CSM, unsigned FieldQuals, bool ConstRHS)
Look up the special member function that would be called by a special member function for a subobject...
static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, bool ConstArg, CXXConstructorDecl *InheritedCtor=nullptr, Sema::InheritedConstructorInfo *Inherited=nullptr)
Determine whether the specified special member function would be constexpr if it were implicitly defi...
static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup, SourceLocation Loc, StringRef Trait, TemplateArgumentListInfo &Args, unsigned DiagID)
static void DiagnoseInvisibleNamespace(const TypoCorrection &Corrected, Sema &S)
static StmtResult buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T, const ExprBuilder &To, const ExprBuilder &From, bool CopyingBaseSubobject, bool Copying)
static const void * GetKeyForMember(ASTContext &Context, CXXCtorInitializer *Member)
static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S, CXXMethodDecl *MD)
static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc, unsigned I, QualType T)
static Sema::ImplicitExceptionSpecification ComputeDefaultedSpecialMemberExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD, CXXSpecialMemberKind CSM, Sema::InheritedConstructorInfo *ICI)
static bool checkComplexDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const ComplexType *CT)
static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
static bool InitializationHasSideEffects(const FieldDecl &FD)
static bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl)
static bool checkArrayLikeDecomposition(Sema &S, ArrayRef< BindingDecl * > Bindings, ValueDecl *Src, QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType)
static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl, DeclStmt *DS, SourceLocation &Cxx1yLoc, Sema::CheckConstexprKind Kind)
Check the given declaration statement is legal within a constexpr function body.
static bool IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2)
Determine whether a using declaration considers the given declarations as "equivalent",...
static TemplateArgumentLoc getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T, uint64_t I)
static bool CheckConstexprDestructorSubobjects(Sema &SemaRef, const CXXDestructorDecl *DD, Sema::CheckConstexprKind Kind)
Determine whether a destructor cannot be constexpr due to.
static bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet< Decl *, 16 > &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind)
Check that the given field is initialized within a constexpr constructor.
static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, const BaseSet &Bases)
Determines if the given class is provably not derived from all of the prospective base classes.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis for SYCL constructs.
static bool isInvalid(LocType Loc, bool *Invalid)
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
const NestedNameSpecifier * Specifier
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
std::pair< CXXConstructorDecl *, bool > findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const
Find the constructor to use for inherited construction of a base class, and whether that base class c...
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
virtual void HandleVTable(CXXRecordDecl *RD)
Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
unsigned getIntWidth(QualType T) const
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
QualType getRecordType(const RecordDecl *Decl) const
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
void Deallocate(void *Ptr) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
const LangOptions & getLangOpts() const
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const
Determine whether the given template names refer to the same template.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built.
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
const TargetInfo & getTargetInfo() const
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Represents an access specifier followed by colon ':'.
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Wrapper for source info for arrays.
TypeLoc getElementLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
Attr - This represents one attribute.
Attr * clone(ASTContext &C) const
attr::Kind getKind() const
SourceLocation getLocation() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
AutoTypeKeyword getKeyword() const
Represents a C++ declaration that introduces decls from somewhere else.
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
void addShadowDecl(UsingShadowDecl *S)
shadow_iterator shadow_begin() const
void removeShadowDecl(UsingShadowDecl *S)
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
static bool isCompoundAssignmentOp(Opcode Opc)
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
A binding in a decomposition declaration.
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Wrapper for source info for block pointers.
This class is used for builtin types like 'int'.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
DeclContext::lookup_iterator Decls
The declarations found inside this base class subobject.
AccessSpecifier Access
The access along this inheritance path.
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
std::list< CXXBasePath >::iterator paths_iterator
Represents a base class of a C++ class.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
QualType getType() const
Retrieves the type of the base class.
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
A boolean literal, per ([C++ lex.bool] Boolean literals).
CXXCatchStmt - This represents a C++ catch block.
Represents a call to a C++ constructor.
static CXXConstructExpr * Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, CXXConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Create a C++ construction expression.
bool isImmediateEscalating() const
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents a C++ constructor within a class.
bool isMoveConstructor(unsigned &TypeQuals) const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
ExplicitSpecifier getExplicitSpecifier()
init_iterator init_begin()
Retrieve an iterator to the first initializer.
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
bool isCopyConstructor(unsigned &TypeQuals) const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
CXXConstructorDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ conversion function within a class.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Represents a C++ base or member initializer.
bool isWritten() const
Determine whether this initializer is explicitly written in the source code.
FieldDecl * getAnyMember() const
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
A use of a default initializer in a constructor or in aggregate initialization.
Represents a C++ destructor within a class.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
A mapping from each virtual member function to its set of final overriders.
Represents a call to an inherited base class constructor from an inheriting constructor.
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Represents a static or instance method of a struct/union/class.
bool isExplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An explicit object member function is a non-static member function with an explic...
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
unsigned getNumExplicitParams() const
overridden_method_range overridden_methods() const
unsigned size_overridden_methods() const
CXXMethodDecl * getMostRecentDecl()
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
method_iterator begin_overridden_methods() const
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
QualType getFunctionObjectParameterType() const
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
The null pointer literal (C++11 [lex.nullptr])
A call to an overloaded operator written using operator syntax.
Represents a C++ struct/union/class.
bool hasConstexprDefaultConstructor() const
Determine whether this class has a constexpr default constructor.
friend_range friends() const
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class....
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
bool implicitCopyConstructorHasConstParam() const
Determine whether an implicit copy constructor for this type would have a parameter with a const-qual...
bool defaultedDestructorIsDeleted() const
true if a defaulted destructor for this class would be deleted.
bool hasInheritedAssignment() const
Determine whether this class has a using-declaration that names a base class assignment operator.
bool allowConstDefaultInit() const
Determine whether declaring a const variable with this type is ok per core issue 253.
bool hasTrivialDestructorForCall() const
bool defaultedMoveConstructorIsDeleted() const
true if a defaulted move constructor for this class would be deleted.
bool isLiteral() const
Determine whether this class is a literal type.
bool hasUserDeclaredMoveAssignment() const
Determine whether this class has had a move assignment declared by the user.
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
bool isLambda() const
Determine whether this class describes a lambda function object.
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12)
bool needsImplicitDefaultConstructor() const
Determine if we need to declare a default constructor for this class.
bool needsImplicitMoveConstructor() const
Determine whether this class should get an implicit move constructor or if any existing special membe...
bool hasUserDeclaredCopyAssignment() const
Determine whether this class has a user-declared copy assignment operator.
method_range methods() const
bool needsOverloadResolutionForCopyAssignment() const
Determine whether we need to eagerly declare a defaulted copy assignment operator for this class.
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
bool defaultedDefaultConstructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class....
void setImplicitMoveAssignmentIsDeleted()
Set that we attempted to declare an implicit move assignment operator, but overload resolution failed...
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
unsigned getNumBases() const
Retrieves the number of base classes of this class.
bool defaultedCopyConstructorIsDeleted() const
true if a defaulted copy constructor for this class would be deleted.
bool hasTrivialCopyConstructorForCall() const
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths, bool LookupInDependent=false) const
Look for entities within the base classes of this C++ class, transitively searching all base class su...
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11,...
base_class_range vbases()
base_class_iterator vbases_begin()
void setImplicitMoveConstructorIsDeleted()
Set that we attempted to declare an implicit move constructor, but overload resolution failed so we d...
bool isAbstract() const
Determine whether this class has a pure virtual function.
bool hasVariantMembers() const
Determine whether this class has any variant members.
void setImplicitCopyConstructorIsDeleted()
Set that we attempted to declare an implicit copy constructor, but overload resolution failed so we d...
bool isDynamicClass() const
bool hasInClassInitializer() const
Whether this class has any in-class initializers for non-static data members (including those in anon...
bool needsImplicitCopyConstructor() const
Determine whether this class needs an implicit copy constructor to be lazily declared.
bool hasIrrelevantDestructor() const
Determine whether this class has a destructor which has no semantic effect.
bool hasNonTrivialCopyConstructorForCall() const
bool hasDirectFields() const
Determine whether this class has direct non-static data members.
bool hasUserDeclaredCopyConstructor() const
Determine whether this class has a user-declared copy constructor.
bool hasDefinition() const
void setImplicitCopyAssignmentIsDeleted()
Set that we attempted to declare an implicit copy assignment operator, but overload resolution failed...
bool needsImplicitDestructor() const
Determine whether this class needs an implicit destructor to be lazily declared.
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class.
bool needsOverloadResolutionForMoveAssignment() const
Determine whether we need to eagerly declare a move assignment operator for this class.
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
bool hasNonTrivialDestructorForCall() const
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
bool hasInheritedConstructor() const
Determine whether this class has a using-declaration that names a user-declared base class constructo...
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class.
bool hasUserDeclaredMoveConstructor() const
Determine whether this class has had a move constructor declared by the user.
bool needsImplicitMoveAssignment() const
Determine whether this class should get an implicit move assignment operator or if any existing speci...
bool isInterfaceLike() const
bool needsImplicitCopyAssignment() const
Determine whether this class needs an implicit copy assignment operator to be lazily declared.
bool hasTrivialMoveConstructorForCall() const
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
bool implicitCopyAssignmentHasConstParam() const
Determine whether an implicit copy assignment operator for this type would have a parameter with a co...
CXXRecordDecl * getDefinition() const
Represents a C++ nested-name-specifier or a global scope specifier.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
Represents the this expression in C++.
SourceLocation getBeginLoc() const
SourceLocation getLocation() const
CXXTryStmt - A C++ try block, including all handlers.
CXXCatchStmt * getHandler(unsigned i)
unsigned getNumHandlers() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
bool isCallToStdMove() const
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastKind getCastKind() const
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Represents a class template specialization, which refers to a class template with a given set of temp...
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
bool isExplicitSpecialization() const
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified 'Kind'.
static StringRef getCategoryString(ComparisonCategoryType Kind)
static StringRef getResultString(ComparisonCategoryResult Kind)
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
const CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
ComparisonCategoryType Kind
The Kind of the comparison category type.
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
Complex values, per C99 6.2.5p11.
QualType getElementType() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
ConditionalOperator - The ?: ternary operator.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
const CXXRecordDecl * getParent() const
Returns the parent of this using shadow declaration, which is the class in which this is declared.
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
NamedDecl * getDecl() const
AccessSpecifier getAccess() const
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
void removeDecl(Decl *D)
Removes a declaration from this context.
void addDecl(Decl *D)
Add the declaration D into this context.
decl_iterator decls_end() const
bool isStdNamespace() const
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Decl::Kind getDeclKind() const
DeclContext * getNonTransparentContext()
decl_iterator decls_begin() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
bool isImmediateEscalating() const
Captures information about "declaration specifiers".
bool isVirtualSpecified() const
bool isModulePrivateSpecified() const
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error.
void ClearStorageClassSpecs()
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Expr * getPackIndexingExpr() const
SourceLocation getExplicitSpecLoc() const
SourceLocation getFriendSpecLoc() const
ParsedType getRepAsType() const
TSCS getThreadStorageClassSpec() const
bool isFriendSpecifiedFirst() const
ParsedAttributes & getAttributes()
SourceLocation getEllipsisLoc() const
SourceLocation getConstSpecLoc() const
SourceRange getExplicitSpecRange() const
bool isInlineSpecified() const
SourceLocation getRestrictSpecLoc() const
bool SetTypeQual(TQ T, SourceLocation Loc)
void ClearConstexprSpec()
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getThreadStorageClassSpecLoc() const
Expr * getRepAsExpr() const
SourceLocation getAtomicSpecLoc() const
SourceLocation getVirtualSpecLoc() const
SourceLocation getConstexprSpecLoc() const
SourceLocation getTypeSpecTypeLoc() const
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
SourceLocation getInlineSpecLoc() const
SourceLocation getUnalignedSpecLoc() const
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
bool hasExplicitSpecifier() const
bool hasConstexprSpecifier() const
static const TST TST_auto
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
SourceLocation getBeginLoc() const LLVM_READONLY
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Kind
Lists the kind of concrete classes of Decl.
void clearIdentifierNamespace()
Clears the namespace of this declaration.
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
@ FOK_Undeclared
A friend of a previously-undeclared entity.
@ FOK_None
Not a friend object.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
bool isInvalidDecl() const
unsigned getIdentifierNamespace() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
bool isLocalExternDecl() const
Determine whether this is a block-scope declaration with linkage.
void setAccess(AccessSpecifier AS)
SourceLocation getLocation() const
@ IDNS_Ordinary
Ordinary names.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setLocalOwningModule(Module *M)
void setImplicit(bool I=true)
void setReferenced(bool R=true)
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
DeclContext * getDeclContext()
The name of a declaration.
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
std::string getAsString() const
Retrieve the human-readable string for this name.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
@ CXXConversionFunctionName
NameKind getNameKind() const
Determine what kind of name this is.
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Represents a ValueDecl that came out of a declarator.
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getNumTemplateParameterLists() const
void setTypeSourceInfo(TypeSourceInfo *TI)
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
ArrayRef< TemplateParameterList * > getTemplateParameterLists() const
The template parameter lists that preceded the declarator.
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
SourceLocation getIdentifierLoc() const
void SetIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
bool hasGroupingParens() const
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
bool isRedeclaration() const
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isFunctionDefinition() const
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
void setInventedTemplateParameterList(TemplateParameterList *Invented)
Sets the template parameter list generated from the explicit template parameters along with any inven...
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool mayHaveDecompositionDeclarator() const
Return true if the context permits a C++17 decomposition declarator.
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
const DecompositionDeclarator & getDecompositionDeclarator() const
bool isDecompositionDeclarator() const
Return whether this declarator is a decomposition declarator.
const IdentifierInfo * getIdentifier() const
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
bool isStaticMember()
Returns true if this declares a static member.
A decomposition declaration.
ArrayRef< BindingDecl * > bindings() const
A parsed C++17 decomposition declarator of the form '[' identifier-list ']'.
ArrayRef< Binding > bindings() const
SourceRange getSourceRange() const
SourceLocation getLSquareLoc() const
Represents a C++17 deduced template specialization type.
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
bool isLastDiagnosticIgnored() const
Determine whether the previous diagnostic was ignored.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
RAII object that enters a new expression evaluation context.
An instance of this object exists for each enum constant that is defined.
enumerator_range enumerators() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
Store information needed for an explicit specifier.
const Expr * getExpr() const
void setKind(ExplicitSpecKind Kind)
This represents one expression.
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
void removeInClassInitializer()
Remove the C++11 in-class initializer from this member.
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList * > FriendTypeTPLists=std::nullopt)
void setUnsupportedFriend(bool Unsupported)
static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList * > Params, FriendUnion Friend, SourceLocation FriendLoc)
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Represents a function declaration or definition.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
ExceptionSpecificationType getExceptionSpecType() const
Gets the ExceptionSpecificationType as declared.
bool isTrivialForCall() const
ConstexprSpecKind getConstexprKind() const
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
void setIsPureVirtual(bool P=true)
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
bool isImmediateFunction() const
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
bool hasCXXExplicitFunctionObjectParameter() const
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
SourceLocation getDefaultLoc() const
QualType getReturnType() const
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
void setWillHaveBody(bool V=true)
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isDeleted() const
Whether this function has been deleted.
void setBodyContainsImmediateEscalatingExpressions(bool Set)
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
bool isExternC() const
Determines whether this function is a function with external, C linkage.
bool isImmediateEscalating() const
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
void setRangeEnd(SourceLocation E)
bool isDefaulted() const
Whether this function is defaulted.
const ParmVarDecl * getNonObjectParameter(unsigned I) const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
ArrayRef< ParmVarDecl * > parameters() const
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
void setConstexprKind(ConstexprSpecKind CSK)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
void setDefaulted(bool D=true)
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
QualType getDeclaredReturnType() const
Get the declared return type, which may differ from the actual return type if the return type is dedu...
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
size_t param_size() const
DeclarationNameInfo getNameInfo() const
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
const ParmVarDecl * getParamDecl(unsigned i) const
Represents a prototype with parameter type info, e.g.
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
ArrayRef< QualType > getParamTypes() const
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
unsigned getNumParams() const
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
ArrayRef< QualType > exceptions() const
QualType getParamType(unsigned i) const
ExtProtoInfo getExtProtoInfo() const
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Declaration of a template function.
Wrapper for source info for functions.
unsigned getNumParams() const
void setParam(unsigned i, ParmVarDecl *VD)
ParmVarDecl * getParam(unsigned i) const
TypeLoc getReturnLoc() const
ExtInfo withCallingConv(CallingConv cc) const
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
QualType getReturnType() const
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
ReservedLiteralSuffixIdStatus isReservedLiteralSuffixId() const
Determine whether this is a name reserved for future standardization or the implementation (C++ [usrl...
bool isPlaceholder() const
StringRef getName() const
Return the actual identifier string.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
IfStmt - This represents an if/then/else.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Represents an implicitly-generated value initialization of an object of a given type.
Represents a field injected from an anonymous union/struct into the parent scope.
ArrayRef< NamedDecl * > chain() const
void setInherited(bool I)
Description of a constructor that was inherited from a base class.
ConstructorUsingShadowDecl * getShadowDecl() const
const TypeClass * getTypePtr() const
Describes an C or C++ initializer list.
unsigned getNumInits() const
const Expr * getInit(unsigned Init) const
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a direct initialization.
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static InitializationKind CreateDirectList(SourceLocation InitLoc)
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent=nullptr)
Create the initialization entity for a base class subobject.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
static InitializedEntity InitializeBinding(VarDecl *Binding)
Create the initialization entity for a structured binding.
static InitializedEntity InitializeMemberFromDefaultMemberInitializer(FieldDecl *Member)
Create the initialization entity for a default member initializer.
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static InitializedEntity InitializeDelegation(QualType Type)
Create the initialization entity for a delegated constructor.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Describes the capture of a variable or of this, or of a C++1y init-capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
capture_range captures() const
Retrieve this lambda's captures.
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
void push_back(const T &LocalValue)
iterator begin(Source *source, bool LocalOnly=false)
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Represents a linkage specification.
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LinkageSpecLanguageIDs Lang, bool HasBraces)
void setRBraceLoc(SourceLocation L)
bool isLocalPackExpansion(const Decl *D)
Determine whether D is a pack expansion created in this scope.
A class for iterating through a result set and possibly filtering out results.
void erase()
Erase the last element returned from this iterator.
Represents the results of name lookup.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
DeclClass * getAsSingle() const
void setLookupName(DeclarationName Name)
Sets the name to look up.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Filter makeFilter()
Create a filter for this result set.
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
NamedDecl * getAcceptableDecl(NamedDecl *D) const
Retrieve the accepted (re)declaration of the given declaration, if there is one.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isVisible(Sema &SemaRef, NamedDecl *D)
Determine whether the given declaration is visible to the program.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
An instance of this class represents the declaration of a property member.
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
SourceLocation getExprLoc() const LLVM_READONLY
Wrapper for source info for member pointers.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Describes a module or submodule.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
bool isExplicitGlobalModule() const
This represents a decl that may have a name.
bool isPlaceholderVar(const LangOptions &LangOpts) const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Represents a C++ namespace alias.
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Represent a C++ namespace.
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
bool isInline() const
Returns true if this is an inline namespace declaration.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
void setRBraceLoc(SourceLocation L)
Class that aids in the construction of nested-name-specifiers along with source-location information ...
A C++ nested-name-specifier augmented with source location information.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
@ Global
The global specifier '::'. There is no stored value.
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
Represents an ObjC class declaration.
The basic abstraction for the target Objective-C runtime.
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
@ CSK_Normal
Normal lookup.
@ CSK_Operator
C++ [over.match.oper]: Lookup of operator function candidates in a call using operator syntax.
SmallVectorImpl< OverloadCandidate >::iterator iterator
MapType::iterator iterator
MapType::const_iterator const_iterator
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
Represents a parameter to a function.
void setDefaultArg(Expr *defarg)
SourceLocation getExplicitObjectParamThisLoc() const
void setUnparsedDefaultArg()
Specify that this parameter has an unparsed default argument.
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
void setUninstantiatedDefaultArg(Expr *arg)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
bool hasUninstantiatedDefaultArg() const
bool hasInheritedDefaultArg() const
bool isExplicitObjectParameter() const
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Expr * getUninstantiatedDefaultArg()
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
void setHasInheritedDefaultArg(bool I=true)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
ParsedAttr - Represents a syntactic attribute.
IdentifierInfo * getPropertyDataSetter() const
IdentifierInfo * getPropertyDataGetter() const
static const ParsedAttributesView & none()
bool hasAttribute(ParsedAttr::Kind K) const
const ParsedAttr * getMSPropertyAttr() const
Wrapper for source info for pointers.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
IdentifierTable & getIdentifierTable()
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
ArrayRef< Expr * > semantics()
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType withConst() const
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
void addConst()
Add the const type qualifier to this QualType.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
bool isConstQualified() const
Determine whether this type is const-qualified.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
The collection of all-type qualifiers we support.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
void removeAddressSpace()
void addAddressSpace(LangAS space, bool AllowDefaultAddrSpace=false)
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_iterator field_end() const
field_range fields() const
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
specific_decl_iterator< FieldDecl > field_iterator
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Scope - A scope is a transient data structure that is used while parsing the program.
void setEntity(DeclContext *E)
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ DeclScope
This is a scope that can contain a declaration.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
static bool isTypeDecoratedWithDeclAttribute(QualType Ty)
A RAII object to enter scope of a compound statement.
std::pair< VarDecl *, Expr * > get() const
For a defaulted function, the kind of defaulted function that it is.
DefaultedComparisonKind asComparison() const
bool isSpecialMember() const
bool isComparison() const
CXXSpecialMemberKind asSpecialMember() const
Helper class that collects exception specifications for implicitly-declared special member functions.
void CalledStmt(Stmt *S)
Integrate an invoked statement into the collected data.
void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method)
Integrate another called method into the collected data.
SpecialMemberOverloadResult - The overloading result for a special member function.
CXXMethodDecl * getMethod() const
RAII object to handle the state changes required to synthesize a function body.
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
void DefineImplicitLambdaToFunctionPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a function pointer.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
CXXConstructorDecl * DeclareImplicitDefaultConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit default constructor for the given class.
bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S)
MergeCXXFunctionDecl - Merge two declarations of the same C++ function, once we already know that the...
Attr * getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition)
Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a containing class.
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D)
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
bool EvaluateStaticAssertMessageAsString(Expr *Message, std::string &Result, ASTContext &Ctx, bool ErrorOnInvalidMessage)
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, SourceLocation ConvLocation, CXXConversionDecl *Conv, Expr *Src)
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Decl * ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec)
NamedDecl * ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope)
bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, const CXXMethodDecl *Old)
void DiagnoseAbstractType(const CXXRecordDecl *RD)
void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow)
Hides a using shadow declaration.
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R=nullptr, const UsingDecl *UD=nullptr)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
bool CheckExplicitObjectOverride(CXXMethodDecl *New, const CXXMethodDecl *Old)
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We've seen a default argument for a function parameter,...
DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD)
Determine the kind of defaulting that would be done for a given function.
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp=false)
void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath)
void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old)
Merge the exception specifications of two variable declarations.
CXXSpecialMemberKind getSpecialMember(const CXXMethodDecl *MD)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupUsingDeclName
Look up all declarations in a scope with the given name, including resolved using declarations.
@ LookupLocalFriendName
Look up a friend of a local class.
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
void DiagnoseSentinelCalls(const NamedDecl *D, SourceLocation Loc, ArrayRef< Expr * > Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD)
Evaluate the implicit exception specification for a defaulted special member function.
ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E)
ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression found in an explicit(bool)...
bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc, RecordDecl *ClassDecl, const IdentifierInfo *Name)
void ActOnFinishCXXNonNestedClass()
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class)
Force the declaration of any implicitly-declared members of this class.
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc, Expr *DefaultArg)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization)
Diagnose a declaration whose declarator-id has the given nested-name-specifier.
void DiagnoseStaticAssertDetails(const Expr *E)
Try to print more useful information about a failed static_assert with expression \E.
void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared move assignment operator.
void ActOnFinishDelayedMemberInitializers(Decl *Record)
void CheckDelegatingCtorCycles()
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
void CheckExplicitObjectMemberFunction(Declarator &D, DeclarationName Name, QualType R, bool IsLambda, DeclContext *DC=nullptr)
bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info)
DiagnoseClassNameShadow - Implement C++ [class.mem]p13: If T is the name of a class,...
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, CXXRecordDecl *Record)
MarkBaseAndMemberDestructorsReferenced - Given a record decl, mark all the non-trivial destructors of...
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, OverloadedOperatorKind Op, const UnresolvedSetImpl &Fns, ArrayRef< Expr * > Args, bool RequiresADL=true)
Perform lookup for an overloaded binary operator.
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, SourceLocation ColonLoc, const ParsedAttributesView &Attrs)
ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
bool isImplicitlyDeleted(FunctionDecl *FD)
Determine whether the given function is an implicitly-deleted special member function.
void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD)
Check a completed declaration of an implicit special member.
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
bool CompleteConstructorCall(CXXConstructorDecl *Constructor, QualType DeclInitType, MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl< Expr * > &ConvertedArgs, bool AllowExplicit=false, bool IsListInitialization=false)
Given a constructor and the set of arguments provided for the constructor, convert the arguments and ...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
bool TemplateParameterListsAreEqual(const TemplateCompareNewDeclInfo &NewInstFrom, TemplateParameterList *New, const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
Decl * ActOnNamespaceAliasDef(Scope *CurScope, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident)
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, InheritedConstructorInfo *ICI=nullptr, bool Diagnose=false)
Determine if a special member function should have a deleted definition when it is defaulted.
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
CXXConstructorDecl * DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit move constructor for the given class.
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc, CodeSynthesisContext::SynthesisKind CSC=CodeSynthesisContext::ExplicitTemplateArgumentSubstitution)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
void SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind, StringLiteral *DeletedMessage=nullptr)
void referenceDLLExportedClassMethods()
void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, CXXDestructorDecl *Dtor)
Do semantic checks to allow the complete destructor variant to be emitted when the destructor is defi...
NamedDecl * ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, InClassInitStyle InitStyle)
ActOnCXXMemberDeclarator - This is invoked when a C++ class member declarator is parsed.
bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckForFunctionMarkedFinal - Checks whether a virtual member function overrides a virtual member fun...
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic=false)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
void handleTagNumbering(const TagDecl *Tag, Scope *TagScope)
void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl)
AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared special functions,...
bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec)
tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
Decl * ActOnConversionDeclarator(CXXConversionDecl *Conversion)
ActOnConversionDeclarator - Called by ActOnDeclarator to complete the declaration of the given C++ co...
@ Other
C++26 [dcl.fct.def.general]p1 function-body: ctor-initializer[opt] compound-statement function-try-bl...
@ Delete
deleted-function-body
QualType BuildStdInitializerList(QualType Element, SourceLocation Loc)
Looks for the std::initializer_list template and instantiates it with Element, or emits an error if i...
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
FieldDecl * HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS)
HandleField - Analyze a field of a C struct or a C++ data member.
FPOptionsOverride CurFPFeatureOverrides()
void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD)
Diagnose methods which overload virtual methods in a base class without overriding any.
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a 'using' declaration.
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, DeclAccessPair Found, QualType ObjectType, SourceLocation Loc, const PartialDiagnostic &Diag)
Is the given member accessible for the purposes of deciding whether to define a special member functi...
BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, const ParsedAttributesView &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
void ActOnFinishFunctionDeclarationDeclarator(Declarator &D)
Called after parsing a function declarator belonging to a function declaration.
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
void CheckConversionDeclarator(Declarator &D, QualType &R, StorageClass &SC)
CheckConversionDeclarator - Called by ActOnDeclarator to check the well-formednes of the conversion f...
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnFinishDelayedCXXMethodDeclaration - We have finished processing the delayed method declaration f...
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
Decl * ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation IdentLoc, IdentifierInfo &II, CXXScopeSpec *SS=nullptr)
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
NamedDecl * ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams)
void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD)
void CheckDelayedMemberExceptionSpecs()
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>.
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD)
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method)
Check whether 'this' shows up in the type of a static member function after the (naturally empty) cv-...
void PopExpressionEvaluationContext()
NamespaceDecl * getOrCreateStdNamespace()
Retrieve the special "std" namespace, which may require us to implicitly define the namespace.
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool isInitListConstructor(const FunctionDecl *Ctor)
Determine whether Ctor is an initializer-list constructor, as defined in [dcl.init....
void ActOnStartFunctionDeclarationDeclarator(Declarator &D, unsigned TemplateParameterDepth)
Called before parsing a function declarator belonging to a function declaration.
std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths)
Builds a string representing ambiguous paths from a specific derived class to different subobjects of...
DefaultedComparisonKind
Kinds of defaulted comparison operator functions.
@ Relational
This is an <, <=, >, or >= that should be implemented as a rewrite in terms of a <=> comparison.
@ NotEqual
This is an operator!= that should be implemented as a rewrite in terms of a == comparison.
@ ThreeWay
This is an operator<=> that should be implemented as a series of subobject comparisons.
@ None
This is not a defaultable comparison operator.
@ Equal
This is an operator== that should be implemented as a series of subobject comparisons.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMemberKind > SpecialMemberDecl
void ActOnStartCXXInClassMemberInitializer()
Enter a new C++ default initializer scope.
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists)
Builds a using declaration.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef< CXXCtorInitializer * > Initializers=std::nullopt)
void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitMoveConstructor - Checks for feasibility of defining this constructor as the move const...
@ TPL_TemplateMatch
We are matching the template parameter lists of two templates that might be redeclarations.
EnumDecl * getStdAlignValT() const
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
void PushFunctionScope()
Enter a new function scope.
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitCopyConstructor - Checks for feasibility of defining this constructor as the copy const...
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_UsingDeclaration
A using declaration.
@ UPPC_ExceptionType
The type of an exception.
@ UPPC_Initializer
An initializer.
@ UPPC_BaseType
The base type of a class type.
@ UPPC_FriendDeclaration
A friend declaration.
@ UPPC_DefaultArgument
A default argument.
@ UPPC_DeclarationType
The type of an arbitrary declaration.
@ UPPC_DataMemberType
The type of a data member.
@ UPPC_StaticAssertExpression
The expression in a static assertion.
Decl * ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *Ident, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UsingDecl, bool IsNested)
ActOnStartNamespaceDef - This is called at the start of a namespace definition.
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl, bool SupportedForCompatibility=false)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc, ComparisonCategoryUsage Usage)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList)
void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent)
DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was not used in the declaration of ...
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
AccessResult CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field)
Checks implicit access to a member in a structured binding.
void EnterTemplatedContext(Scope *S, DeclContext *DC)
Enter a template parameter scope, after it's been associated with a particular DeclContext.
void ActOnBaseSpecifiers(Decl *ClassDecl, MutableArrayRef< CXXBaseSpecifier * > Bases)
ActOnBaseSpecifiers - Attach the given base specifiers to the class, after checking whether there are...
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, DefaultedComparisonKind DCK)
bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, const NamedDecl *B)
Determine if A and B are equivalent internal linkage declarations from different modules,...
bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, CheckConstexprKind Kind)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
NamedDecl * getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R)
Return the declaration shadowed by the given typedef D, or null if it doesn't shadow any declaration ...
void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, ArrayRef< Expr * > Args, OverloadCandidateSet &CandidateSet)
AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (...
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD)
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr * > ConstraintExprs, const MultiLevelTemplateArgumentList &TemplateArgLists, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a 'conjunction') given...
const LangOptions & LangOpts
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock)
void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, bool ConstexprOnly=false)
MarkVirtualMembersReferenced - Will mark all members of the given CXXRecordDecl referenced.
const LangOptions & getLangOpts() const
ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl)
Wrap the expression in a ConstantExpr if it is a potential immediate invocation.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
void DefineInheritingConstructor(SourceLocation UseLoc, CXXConstructorDecl *Constructor)
Define the specified inheriting constructor.
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn)
Perform semantic checking of a new function declaration.
CXXRecordDecl * getStdBadAlloc() const
QualType CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckDestructorDeclarator - Called by ActOnDeclarator to check the well-formednes of the destructor d...
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void NoteHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
CXXMethodDecl * DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit move assignment operator for the given class.
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
void CheckCXXDefaultArguments(FunctionDecl *FD)
Helpers for dealing with blocks and functions.
@ DefaultedOperator
A defaulted 'operator<=>' needed the comparison category.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, bool DefinitionRequired=false)
Note that the vtable for the given class was used at the given location.
NamedDecl * BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, TypeSourceInfo *EnumType, EnumDecl *ED)
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, const CXXRecordDecl *RD)
Mark the exception specifications of all virtual member functions in the given class as needed.
ExprResult BuildConvertedConstantExpression(Expr *From, QualType T, CCEKind CCE, NamedDecl *Dest=nullptr)
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, CXXScopeSpec *SS=nullptr)
Require that the EnumDecl is completed with its enumerators defined or instantiated.
OverloadKind CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &OldDecls, NamedDecl *&OldDecl, bool UseMemberUsingDeclRules)
Determine whether the given New declaration is an overload of the declarations in Old.
bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl)
CheckOverloadedOperatorDeclaration - Check whether the declaration of this overloaded operator is wel...
void ExitDeclaratorContext(Scope *S)
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir)
void CheckConstructor(CXXConstructorDecl *Constructor)
CheckConstructor - Checks a fully-formed constructor for well-formedness, issuing any diagnostics req...
void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, CXXConversionDecl *Conv)
Define the "body" of the conversion from a lambda object to a block pointer.
void DefineImplicitDestructor(SourceLocation CurrentLocation, CXXDestructorDecl *Destructor)
DefineImplicitDestructor - Checks for feasibility of defining this destructor as the default destruct...
void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMemberKind CSM)
Diagnose why the specified class does not have a trivial special member of the given kind.
void popCodeSynthesisContext()
CXXRecordDecl * getCurrentClass(Scope *S, const CXXScopeSpec *SS)
Get the class that is directly named by the current context.
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr)
bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method)
Check whether 'this' shows up in the attributes of the given static member function.
CXXBaseSpecifier * CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
ActOnBaseSpecifier - Parsed a base specifier.
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, CXXConstructorDecl *Constructor)
DefineImplicitDefaultConstructor - Checks for feasibility of defining this constructor as the default...
std::pair< CXXRecordDecl *, SourceLocation > VTableUse
The list of classes whose vtables have been used within this translation unit, and the source locatio...
ExprResult DefaultLvalueConversion(Expr *E)
bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath=nullptr, bool IgnoreAccess=false)
bool CheckDeductionGuideDeclarator(Declarator &D, QualType &R, StorageClass &SC)
Check the validity of a declarator that we parsed for a deduction-guide.
void DiagPlaceholderVariableDefinition(SourceLocation Loc)
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
bool DiagnoseUseOfOverloadedDecl(NamedDecl *D, SourceLocation Loc)
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
void ActOnFinishInlineFunctionDef(FunctionDecl *D)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true, bool WantSize=false, bool WantAligned=false)
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause,...
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Module * getCurrentModule() const
Get the module unit whose scope we are currently within.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MethodDecl)
Defines an implicitly-declared copy assignment operator.
bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer)
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
@ TAH_ConsiderTrivialABI
The triviality of a method affected by "trivial_abi".
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl)
CheckLiteralOperatorDeclaration - Check whether the declaration of this literal operator function is ...
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
CXXMethodDecl * DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl)
Declare the implicit copy assignment operator for the given class.
void MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl< const RecordType * > *DirectVirtualBases=nullptr)
Mark destructors of virtual bases of this class referenced.
void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD)
Check that the C++ class annoated with "trivial_abi" satisfies all the conditions that are needed for...
SourceManager & getSourceManager() const
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
unsigned ActOnReenterTemplateScope(Decl *Template, llvm::function_ref< Scope *()> EnterScope)
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
FunctionDecl * SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, FunctionDecl *Spaceship)
Substitute the name and return type of a defaulted 'operator<=>' to form an implicit 'operator=='.
NamedDecl * ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists)
Decl * ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams)
Handle a friend type declaration.
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
void EnterDeclaratorContext(Scope *S, DeclContext *DC)
EnterDeclaratorContext - Used when we must lookup names in the context of a declarator's nested name ...
bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, DefaultedComparisonKind DCK)
bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method)
Whether this' shows up in the exception specification of a static member function.
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
Decl * ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc, Expr *LangStr, SourceLocation LBraceLoc)
ActOnStartLinkageSpecification - Parsed the beginning of a C++ linkage specification,...
void FilterUsingLookup(Scope *S, LookupResult &lookup)
Remove decls we can't actually see from a lookup being used to declare shadow using decls.
void actOnDelayedExceptionSpecification(Decl *Method, ExceptionSpecificationType EST, SourceRange SpecificationRange, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr)
Add an exception-specification to the given member function (or member function template).
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, SourceLocation EqualLoc, Expr *Init)
This is invoked after parsing an in-class initializer for a non-static C++ class member,...
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)
PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute.
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, const ImplicitConversionSequence &ICS, AssignmentAction Action, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType ...
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R)
Diagnose variable or built-in function shadowing.
void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor)
Build an exception spec for destructors that don't have one.
Decl * ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *AssertMessageExpr, SourceLocation RParenLoc)
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool CheckImmediateEscalatingFunctionDefinition(FunctionDecl *FD, const sema::FunctionScopeInfo *FSI)
void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
void CheckCompleteVariableDeclaration(VarDecl *VD)
ExprResult ActOnRequiresClause(ExprResult ConstraintExpr)
void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class)
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL,...
RedeclarationKind forRedeclarationInCurContext() const
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
@ CCEK_StaticAssertMessageSize
Call to size() in a static assert message.
@ CCEK_ExplicitBool
Condition in an explicit(bool) specifier.
@ CCEK_StaticAssertMessageData
Call to data() in a static assert message.
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
ASTContext & getASTContext() const
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
void ActOnFinishCXXMemberDecls()
Perform any semantic analysis which needs to be delayed until all pending class member declarations h...
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
@ Ovl_NonFunction
This is not an overload because the lookup results contain a non-function.
@ Ovl_Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
@ Ovl_Match
This is not an overload because the signature exactly matches an existing declaration.
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Decl * ActOnFinishLinkageSpecification(Scope *S, Decl *LinkageSpec, SourceLocation RBraceLoc)
ActOnFinishLinkageSpecification - Complete the definition of the C++ linkage specification LinkageSpe...
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool inferObjCARCLifetime(ValueDecl *decl)
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace)
ActOnFinishNamespaceDef - This callback is called after a namespace is exited.
MemInitResult BuildMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, Expr *Init, SourceLocation EllipsisLoc)
Handle a C++ member initializer.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
void CheckExplicitObjectLambda(Declarator &D)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD)
void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)
PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the initializer (and its subobjects) is sufficient for initializing the en...
FPOptions & getCurFPFeatures()
void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record)
Perform semantic checks on a class definition that has been completing, introducing implicitly-declar...
void DiscardCleanupsInEvaluationContext()
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
bool CheckDestructor(CXXDestructorDecl *Destructor)
CheckDestructor - Checks a fully-formed destructor definition for well-formedness,...
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > Expansions)
MemInitResult ActOnMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, SourceLocation LParenLoc, ArrayRef< Expr * > Args, SourceLocation RParenLoc, SourceLocation EllipsisLoc)
Handle a C++ member initializer using parentheses syntax.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc, StringLiteral *Message=nullptr)
void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method)
ActOnStartDelayedCXXMethodDeclaration - We have completed parsing a top-level (non-nested) C++ class,...
DiagnosticsEngine & Diags
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
CXXConstructorDecl * DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl)
Declare the implicit copy constructor for the given class.
NamespaceDecl * getStdNamespace() const
void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, FunctionDecl *Spaceship)
bool AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef< CXXBaseSpecifier * > Bases)
Performs the actual work of attaching the given base class specifiers to a C++ class.
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
NamedDecl * ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *D, LookupResult &Previous, bool &Redeclaration)
ActOnTypedefNameDecl - Perform semantic checking for a declaration which declares a typedef-name,...
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC)
CheckConstructorDeclarator - Called by ActOnDeclarator to check the well-formedness of the constructo...
ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, SourceLocation EqualLoc)
void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace)
Filters out lookup results that don't fall within the given scope as determined by isDeclInScope.
FunctionDecl * FindDeallocationFunctionForDestructor(SourceLocation StartLoc, CXXRecordDecl *RD)
ExprResult ConvertMemberDefaultInitExpression(FieldDecl *FD, Expr *InitExpr, SourceLocation InitLoc)
bool IsInvalidSMECallConversion(QualType FromType, QualType ToType)
static Scope * getScopeForDeclContext(Scope *S, DeclContext *DC)
Finds the scope corresponding to the given decl context, if it happens to be an enclosing scope.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
bool isUsualDeallocationFunction(const CXXMethodDecl *FD)
void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD)
Produce notes explaining why a defaulted function was defined as deleted.
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionExceptionSpec - Checks whether the exception spec is a subset of base spec.
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, const CXXMethodDecl *Old)
CheckOverridingFunctionReturnType - Checks whether the return types are covariant,...
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr * > Args, SmallVectorImpl< Expr * > &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
Decl * ActOnDeclarator(Scope *S, Declarator &D)
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
MSPropertyDecl * HandleMSProperty(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr)
HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
bool CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old)
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc)
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
@ CheckValid
Identify whether this function satisfies the formal rules for constexpr functions in the current lanu...
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
void LoadExternalVTableUses()
Load any externally-stored vtable uses.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Decl * ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, SourceLocation NamespcLoc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *NamespcName, const ParsedAttributesView &AttrList)
DiagnosticsEngine & getDiagnostics() const
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, QualType FromType, QualType ToType)
HandleFunctionTypeMismatch - Gives diagnostic information for differeing function types.
void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D)
void FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl< CXXMethodDecl * > &OverloadedMethods)
Check if a method overloads virtual methods in a base class without overriding any.
IdentifierResolver IdResolver
DeclResult ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, unsigned TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, MultiTemplateParamsArg TempParamLists)
Handle a friend tag declaration where the scope specifier was templated.
DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class)
Look up the constructors for the given class.
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
ExprResult ActOnCXXThis(SourceLocation Loc)
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
CXXConstructorDecl * findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, ConstructorUsingShadowDecl *DerivedShadow)
Given a derived-class using shadow declaration for a constructor and the correspnding base class cons...
void warnOnReservedIdentifier(const NamedDecl *D)
bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, SourceLocation DefaultLoc)
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined.
NamedDecl * ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef< BindingDecl * > Bindings=std::nullopt)
Decl * ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList)
void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param)
ActOnDelayedCXXMethodParameter - We've already started a delayed C++ method declaration.
bool isAbstractType(SourceLocation Loc, QualType T)
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *Init=nullptr, bool SkipImmediateInvocations=true)
Instantiate or parse a C++ default argument expression as necessary.
ValueDecl * tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl, const IdentifierInfo *MemberOrBase)
ASTMutationListener * getASTMutationListener() const
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
void DiagnoseImmediateEscalatingReason(FunctionDecl *FD)
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType)
FinalizeVarWithDestructor - Prepare for calling destructor on the constructed variable.
CXXDestructorDecl * DeclareImplicitDestructor(CXXRecordDecl *ClassDecl)
Declare the implicit destructor for the given class.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
void setBegin(SourceLocation b)
SourceLocation getEnd() const
SourceLocation getBegin() const
void setEnd(SourceLocation e)
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, Expr *Message, SourceLocation RParenLoc, bool Failed)
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix)
Determine whether a suffix is a valid ud-suffix.
StringLiteral - This represents a string literal expression, e.g.
bool isUnevaluated() const
StringRef getString() const
Represents the declaration of a struct/union/class/enum.
bool isBeingDefined() const
Return true if this decl is currently being defined.
StringRef getKindName() const
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TagKind getTagKind() const
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change,...
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
bool hasKeyFunctions() const
Does this ABI use key functions? If so, class data such as the vtable is emitted with strong linkage ...
virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
A convenient class for passing around template argument information.
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
TypeSourceInfo * getTypeSourceInfo() const
const TemplateArgument & getArgument() const
Represents a template argument.
@ Type
The template argument is a type.
ArgKind getKind() const
Return the kind of stored template argument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
@ UsingTemplate
A template name that refers to a template declaration found through a specific using shadow declarati...
@ Template
A single template declaration.
Stores a list of template parameters for a TemplateDecl and its derived classes.
SourceRange getSourceRange() const LLVM_READONLY
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to form a template specialization.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
NamedDecl * getParam(unsigned Idx)
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
SourceLocation getTemplateLoc() const
unsigned getNumArgs() const
TemplateArgumentLoc getArgLoc(unsigned i) const
Represents a type template specialization; the template must be a class template, a type alias templa...
Declaration of a template type parameter.
unsigned getIndex() const
Retrieve the index of the template parameter.
unsigned getDepth() const
Retrieve the depth of the template parameter.
unsigned getIndex() const
unsigned getDepth() const
The top declaration context.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Declaration of an alias template.
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
Represents a declaration of a type.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
QualType getType() const
Get the type for which this source info wrapper provides information.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
TypeLoc IgnoreParens() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceRange getLocalSourceRange() const
Get the local source range.
TypeLocClass getTypeLocClass() const
SourceLocation getEndLoc() const
Get the end source location.
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static StringRef getTagTypeKindName(TagTypeKind Kind)
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isUndeducedAutoType() const
bool isRValueReferenceType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isLValueReferenceType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
QualType getCanonicalTypeInternal() const
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isFunctionProtoType() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isRealFloatingType() const
Floating point categories.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
Simple class containing the result of Sema::CorrectTypo.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclClass * getCorrectionDeclAs() const
SourceRange getCorrectionRange() const
void WillReplaceSpecifier(bool ForceReplacement)
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
static bool isIncrementDecrementOp(Opcode Op)
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
Represents a C++ unqualified-id that has been parsed.
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
UnionParsedTemplateTy TemplateName
When Kind == IK_DeductionGuideName, the parsed template-name.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent)
A set of unresolved declarations.
ArrayRef< DeclAccessPair > pairs() const
The iterator over UnresolvedSets.
A set of unresolved declarations.
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Represents a dependent using declaration which was marked with typename.
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Represents a dependent using declaration which was not marked with typename.
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Represents a C++ using-declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
bool hasTypename() const
Return true if the using declaration has 'typename'.
DeclarationNameInfo getNameInfo() const
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Represents C++ using-directive.
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Represents a C++ using-enum-declaration.
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, TypeSourceInfo *EnumType)
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > UsingDecls)
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
static UsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, DeclarationName Name, BaseUsingDecl *Introducer, NamedDecl *Target)
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
bool isInlineSpecified() const
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
bool isStaticDataMember() const
Determines whether this is a static data member.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool evaluateDestruction(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the destruction of this variable to determine if it constitutes constant destruction.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
const Expr * getInit() const
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
ThreadStorageClassSpecifier getTSCSpec() const
@ TLS_Dynamic
TLS with a dynamic initializer.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
void setExceptionVariable(bool EV)
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Declaration of a variable template.
Represents a GCC generic vector type.
unsigned getNumElements() const
QualType getElementType() const
Represents a C++11 virt-specifier-seq.
SourceLocation getOverrideLoc() const
SourceLocation getLastLocation() const
bool isOverrideSpecified() const
SourceLocation getFinalLoc() const
bool isFinalSpecified() const
bool isFinalSpelledSealed() const
Retains information about a function, method, or block that is currently being parsed.
bool FoundImmediateEscalatingExpression
Whether we found an immediate-escalating expression.
Defines the clang::TargetInfo interface.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
@ After
Like System, but searched after the system directories.
@ FixIt
Parse and apply any fixits to the source.
static T getParam(const InterpFrame *Frame, unsigned Index)
bool This(InterpState &S, CodePtr OpPC)
bool Inc(InterpState &S, CodePtr OpPC)
1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...
bool LE(InterpState &S, CodePtr OpPC)
bool Zero(InterpState &S, CodePtr OpPC)
bool Init(InterpState &S, CodePtr OpPC)
bool Comp(InterpState &S, CodePtr OpPC)
1) Pops the value from the stack.
std::string toString(const til::SExpr *E)
The JSON file list parser is used to communicate input to InstallAPI.
@ If
'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
bool FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI)
TypeSpecifierType
Specifies the kind of type.
@ TST_typename_pack_indexing
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ OR_Deleted
Succeeded, but refers to a deleted function.
@ OR_Success
Overload resolution succeeded.
@ OR_Ambiguous
Ambiguous candidates found.
@ OR_No_Viable_Function
No viable function found.
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
InClassInitStyle
In-class initialization styles for non-static data members.
@ ICIS_ListInit
Direct list-initialization.
@ ICIS_NoInit
No in-class initializer.
@ RQ_None
No ref-qualifier was provided.
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
@ OCD_AmbiguousCandidates
Requests that only tied-for-best candidates be shown.
@ OCD_AllCandidates
Requests that all candidates be shown.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
StorageClass
Storage classes.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
ComparisonCategoryType commonComparisonType(ComparisonCategoryType A, ComparisonCategoryType B)
Determine the common comparison type, as defined in C++2a [class.spaceship]p4.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Language
The language for the input, used to select and validate the language standard and possible actions.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
void EscapeStringForDiagnostic(StringRef Str, SmallVectorImpl< char > &OutStr)
EscapeStringForDiagnostic - Append Str to the diagnostic buffer, escaping non-printable characters an...
ReservedLiteralSuffixIdStatus
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ CanPassInRegs
The argument of this type can be passed directly in registers.
@ CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
@ CannotPassInRegs
The argument of this type cannot be passed directly in registers.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
ComparisonCategoryType
An enumeration representing the different comparison categories types.
ActionResult< Stmt * > StmtResult
CXXSpecialMemberKind
Kinds of C++ special members.
OverloadedOperatorKind getRewrittenOverloadedOperator(OverloadedOperatorKind Kind)
Get the other overloaded operator that the given operator can be rewritten into, if any such operator...
@ TNK_Concept_template
The name refers to a concept.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
bool isExternallyVisible(Linkage L)
@ Other
Other implicit parameter.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
MutableArrayRef< Expr * > MultiExprArg
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
float __ovld __cnfn distance(float, float)
Returns the distance between p0 and p1.
bool hasValidIntValue() const
True iff we've successfully evaluated the variable as a constant expression and extracted its integer...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
SourceLocation getEndLoc() const LLVM_READONLY
bool containsUnexpandedParameterPack() const
Determine whether this name contains an unexpanded parameter pack.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
bool hasMutableQualifier() const
Determine whether this lambda-declarator contains a 'mutable' qualifier.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
void freeParams()
Reset the parameter list to having zero parameters.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
std::unique_ptr< CachedTokens > DefaultArgTokens
DefaultArgTokens - When the parameter's default argument cannot be parsed immediately (because it occ...
One instance of this struct is used for each type in a declarator that is parsed.
enum clang::DeclaratorChunk::@219 Kind
EvalResult is a struct with detailed info about an evaluated expression.
Holds information about the various types of exception specification.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
RefQualifierKind RefQualifier
FunctionType::ExtInfo ExtInfo
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Information about operator rewrites to consider when adding operator functions to a candidate set.
Describes how types, statements, expressions, and declarations should be printed.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
@ MarkingClassDllexported
We are marking a class as __dllexport.
@ InitializingStructuredBinding
We are initializing a structured binding.
@ ExceptionSpecEvaluation
We are computing the exception specification for a defaulted special member function.
@ DeclaringSpecialMember
We are declaring an implicit special member function.
@ DeclaringImplicitEqualityComparison
We are declaring an implicit 'operator==' for a defaulted 'operator<=>'.
Decl * Entity
The entity that is being synthesized.
CXXSpecialMemberKind SpecialMember
The special member being declared or defined.
Abstract class used to diagnose incomplete types.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
Information about a template-id annotation token.
TemplateNameKind Kind
The kind of template that Template refers to.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
OpaquePtr< T > get() const